@salesforce/lds-runtime-webruntime 0.1.0-dev1

package/dist/ldsWebruntimeOneStoreInit.js

@@ -0,0 +1,4459 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { getInstrumentation } from 'o11y/client';
+import 'force/luvioTypeNormalization1';
+import { setServices } from 'force/luvioServiceProvisioner1';
+export { default, resolve, setServices } from 'force/luvioServiceProvisioner1';
+import { getSfapJwt } from 'force/clwrSfapExchange';
+import language from '@salesforce/i18n/lang';
+import isDesignMode from '@app/isDesignMode';
+import isPreviewMode from '@app/isPreviewMode';
+import authenticationCookieName from '@app/authenticationCookieName';
+import apiBasePath from '@app/apiBasePath';
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+const { create, freeze, keys, entries } = Object;
+const { isArray: isArray$1 } = Array;
+const { stringify: stringify$1, parse: parse$1 } = JSON;
+const LogLevelMap$1 = {
+  TRACE: 4,
+  DEBUG: 3,
+  INFO: 2,
+  WARN: 1,
+  ERROR: 0
+};
+let ConsoleLogger$1 = 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);
+  }
+  debug(message) {
+    this.log("DEBUG", message);
+  }
+  info(message) {
+    this.log("INFO", message);
+  }
+  warn(message) {
+    this.log("WARN", message);
+  }
+  error(message) {
+    this.log("ERROR", message);
+  }
+  log(level, message) {
+    if (LogLevelMap$1[level] > LogLevelMap$1[this.level]) {
+      return;
+    }
+    this.printer(this.formatter(level, message));
+  }
+};
+let Ok$2 = class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+};
+let Err$1 = class Err {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+};
+const ok$2 = (value) => new Ok$2(value);
+const err$1 = (err2) => new Err$1(err2);
+function isResult(value) {
+  return value != null && typeof value === "object" && "isOk" in value && "isErr" in value && typeof value.isOk === "function" && typeof value.isErr === "function" && (value.isOk() === true && value.isErr() === false && "value" in value || value.isOk() === false && value.isErr() === true && "error" in value);
+}
+function isSubscribable(obj) {
+  return typeof obj === "object" && obj !== null && "subscribe" in obj && typeof obj.subscribe === "function" && "refresh" in obj && typeof obj.refresh === "function";
+}
+function isSubscribableResult(x) {
+  if (!isResult(x)) {
+    return false;
+  }
+  return isSubscribable(x.isOk() ? x.value : x.error);
+}
+function buildSubscribableResult$1(result, subscribe, refresh) {
+  if (result.isOk()) {
+    return ok$2({ data: result.value, subscribe, refresh });
+  } else {
+    return err$1({ failure: result.error, subscribe, refresh });
+  }
+}
+function resolvedPromiseLike$3(result) {
+  if (isPromiseLike$3(result)) {
+    return result.then((nextResult) => nextResult);
+  }
+  return {
+    then: (onFulfilled, _onRejected) => {
+      try {
+        return resolvedPromiseLike$3(onFulfilled(result));
+      } catch (e) {
+        if (onFulfilled === void 0) {
+          return resolvedPromiseLike$3(result);
+        }
+        return rejectedPromiseLike$3(e);
+      }
+    }
+  };
+}
+function rejectedPromiseLike$3(reason) {
+  if (isPromiseLike$3(reason)) {
+    return reason.then((nextResult) => nextResult);
+  }
+  return {
+    then: (_onFulfilled, onRejected) => {
+      if (typeof onRejected === "function") {
+        try {
+          return resolvedPromiseLike$3(onRejected(reason));
+        } catch (e) {
+          return rejectedPromiseLike$3(e);
+        }
+      }
+      return rejectedPromiseLike$3(reason);
+    }
+  };
+}
+function isPromiseLike$3(x) {
+  return typeof (x == null ? void 0 : x.then) === "function";
+}
+function stableJSONStringify(node) {
+  if (node && node.toJSON && typeof node.toJSON === "function") {
+    node = node.toJSON();
+  }
+  if (node === void 0) {
+    return;
+  }
+  if (typeof node === "number") {
+    return isFinite(node) ? "" + node : "null";
+  }
+  if (typeof node !== "object") {
+    return stringify$1(node);
+  }
+  let i;
+  let out;
+  if (isArray$1(node)) {
+    out = "[";
+    for (i = 0; i < node.length; i++) {
+      if (i) {
+        out += ",";
+      }
+      out += stableJSONStringify(node[i]) || "null";
+    }
+    return out + "]";
+  }
+  if (node === null) {
+    return "null";
+  }
+  const objKeys = keys(node).sort();
+  out = "";
+  for (i = 0; i < objKeys.length; i++) {
+    const key = objKeys[i];
+    const value = stableJSONStringify(node[key]);
+    if (!value) {
+      continue;
+    }
+    if (out) {
+      out += ",";
+    }
+    out += stringify$1(key) + ":" + value;
+  }
+  return "{" + out + "}";
+}
+function toError(x) {
+  if (x instanceof Error) {
+    return x;
+  }
+  return new Error(typeof x === "string" ? x : JSON.stringify(x));
+}
+var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
+  HttpStatusCode2[HttpStatusCode2["Ok"] = 200] = "Ok";
+  HttpStatusCode2[HttpStatusCode2["Created"] = 201] = "Created";
+  HttpStatusCode2[HttpStatusCode2["NoContent"] = 204] = "NoContent";
+  HttpStatusCode2[HttpStatusCode2["NotModified"] = 304] = "NotModified";
+  HttpStatusCode2[HttpStatusCode2["BadRequest"] = 400] = "BadRequest";
+  HttpStatusCode2[HttpStatusCode2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatusCode2[HttpStatusCode2["Forbidden"] = 403] = "Forbidden";
+  HttpStatusCode2[HttpStatusCode2["NotFound"] = 404] = "NotFound";
+  HttpStatusCode2[HttpStatusCode2["ServerError"] = 500] = "ServerError";
+  HttpStatusCode2[HttpStatusCode2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  return HttpStatusCode2;
+})(HttpStatusCode || {});
+function getStatusText(status) {
+  switch (status) {
+    case 200:
+      return "OK";
+    case 201:
+      return "Created";
+    case 304:
+      return "Not Modified";
+    case 400:
+      return "Bad Request";
+    case 404:
+      return "Not Found";
+    case 500:
+      return "Server Error";
+    default:
+      return `Unexpected HTTP Status Code: ${status}`;
+  }
+}
+class FetchResponse extends Error {
+  constructor(status, body, headers) {
+    super();
+    this.status = status;
+    this.body = body;
+    this.headers = headers || {};
+    this.ok = status >= 200 && this.status <= 299;
+    this.statusText = getStatusText(status);
+  }
+}
+class InternalError extends Error {
+  constructor(data) {
+    super();
+    this.data = data;
+    this.type = "internal";
+  }
+}
+class UserVisibleError extends Error {
+  constructor(data) {
+    super();
+    this.data = data;
+    this.type = "user-visible";
+  }
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class BaseCommand {
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
+  constructor(services) {
+    super();
+    this.services = services;
+    this.subscriptions = [];
+    this.exposeSubscribeAndRefresh = false;
+  }
+  execute() {
+    const result = this.fetch();
+    if (this.exposeSubscribeAndRefresh) {
+      return this.fetchSubscribableResult(result);
+    }
+    return result;
+  }
+  fetchSubscribableResult(res) {
+    return res.then((networkResult) => {
+      return buildSubscribableResult$1(
+        networkResult,
+        (cb) => {
+          this.subscriptions.push(cb);
+          return () => {
+            this.subscriptions = this.subscriptions.filter((cb2) => cb2 !== cb);
+          };
+        },
+        () => this.refresh()
+      );
+    });
+  }
+  refresh() {
+    return this.execute().then((newResult) => {
+      if (isSubscribableResult(newResult)) {
+        const value = newResult.isOk() ? ok$2(newResult.value.data) : err$1(newResult.error.failure);
+        this.subscriptions.forEach((cb) => {
+          cb(value);
+        });
+      }
+      return ok$2(void 0);
+    });
+  }
+  async afterRequestHooks(_options) {
+  }
+};
+function buildServiceDescriptor$j() {
+  return {
+    type: "networkCommandBaseClass",
+    version: "1.0",
+    service: NetworkCommand$1
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class AuraNetworkCommand extends NetworkCommand$1 {
+  constructor(services) {
+    super(services);
+    this.services = services;
+    this.actionConfig = {
+      background: false,
+      hotspot: true,
+      longRunning: false,
+      storable: false
+    };
+    this.networkPreference = "aura";
+  }
+  get fetchParams() {
+    throw new Error(
+      "Fetch parameters must be specified when using HTTP transport on an Aura adapter"
+    );
+  }
+  coerceAuraErrors(auraErrors) {
+    return toError(auraErrors[0]);
+  }
+  async coerceFetchErrors(errorResponse) {
+    return toError(errorResponse.statusText);
+  }
+  convertAuraResponseToData(responsePromise, coerceError) {
+    return responsePromise.then((response) => {
+      const auraReturnValue = response.getReturnValue();
+      try {
+        this.afterRequestHooks({ statusCode: 200 });
+      } catch (e) {
+      }
+      return ok$2(auraReturnValue);
+    }).catch((error) => {
+      if (!error || !error.getError) {
+        return err$1(toError("Failed to get error from response"));
+      } else {
+        const actionErrors = error.getError();
+        if (actionErrors.length > 0) {
+          return err$1(coerceError(actionErrors));
+        } else {
+          return err$1(toError("Error fetching component"));
+        }
+      }
+    });
+  }
+  convertFetchResponseToData(response) {
+    return response.then(
+      (response2) => {
+        if (response2.ok) {
+          return response2.json().then(
+            (json) => ok$2(json),
+            (reason) => err$1(toError(reason))
+          ).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        } else {
+          return this.coerceFetchErrors(response2).then((coercedError) => {
+            return err$1(coercedError);
+          }).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        }
+      },
+      (reason) => err$1(toError(reason))
+    );
+  }
+  shouldUseAuraNetwork() {
+    return this.services.auraNetwork !== void 0 && (this.networkPreference === "aura" || !this.services.fetch);
+  }
+  shouldUseFetch() {
+    return this.services.fetch !== void 0 && (this.networkPreference === "http" || !this.services.auraNetwork);
+  }
+  fetch() {
+    if (this.shouldUseAuraNetwork()) {
+      return this.convertAuraResponseToData(
+        this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig),
+        this.coerceAuraErrors
+      );
+    } else if (this.shouldUseFetch()) {
+      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+  }
+}
+function buildServiceDescriptor$i() {
+  return {
+    type: "auraNetworkCommandBaseClass",
+    version: "1.0",
+    service: AuraNetworkCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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
+ */
+const { isArray } = Array;
+let Ok$1 = class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+};
+class Err {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+}
+const ok$1 = (value) => new Ok$1(value);
+const err = (err2) => new Err(err2);
+function buildSubscribableResult(result, subscribe, refresh) {
+  if (result.isOk()) {
+    return ok$1({ data: result.value, subscribe, refresh });
+  } else {
+    return err({ failure: result.error, subscribe, refresh });
+  }
+}
+function resolvedPromiseLike$2(result) {
+  if (isPromiseLike$2(result)) {
+    return result.then((nextResult) => nextResult);
+  }
+  return {
+    then: (onFulfilled, _onRejected) => {
+      try {
+        return resolvedPromiseLike$2(onFulfilled(result));
+      } catch (e) {
+        if (onFulfilled === void 0) {
+          return resolvedPromiseLike$2(result);
+        }
+        return rejectedPromiseLike$2(e);
+      }
+    }
+  };
+}
+function rejectedPromiseLike$2(reason) {
+  if (isPromiseLike$2(reason)) {
+    return reason.then((nextResult) => nextResult);
+  }
+  return {
+    then: (_onFulfilled, onRejected) => {
+      if (typeof onRejected === "function") {
+        try {
+          return resolvedPromiseLike$2(onRejected(reason));
+        } catch (e) {
+          return rejectedPromiseLike$2(e);
+        }
+      }
+      return rejectedPromiseLike$2(reason);
+    }
+  };
+}
+function isPromiseLike$2(x) {
+  return typeof (x == null ? void 0 : x.then) === "function";
+}
+function deepEquals(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(x)) {
+    if (!isArray(y) || x.length !== y.length) {
+      return false;
+    }
+    for (let i = 0; i < x.length; ++i) {
+      if (!deepEquals(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(x[key], y[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return x === y;
+}
+function setOverlaps(setA, setB) {
+  if (setA.size > setB.size) {
+    for (const key of setB.keys()) {
+      if (setA.has(key)) {
+        return true;
+      }
+    }
+  } else {
+    for (const key of setA) {
+      if (setB.has(key)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+class CacheControlRequestRunner {
+  constructor(readFromCache, requestFromNetwork, writeToCache) {
+    this.readFromCacheInternal = readFromCache;
+    this.requestFromNetworkInternal = requestFromNetwork;
+    this.writeToCacheInternal = writeToCache;
+  }
+  readFromCache(cache) {
+    const resultPromise = this.readFromCacheInternal(cache);
+    return resultPromise.then((result) => {
+      if (result.isErr()) {
+        return err(result.error.failure);
+      }
+      this.returnData = result;
+      return ok$1(void 0);
+    });
+  }
+  requestFromNetwork() {
+    const that = this;
+    return (async function* () {
+      const result = await that.requestFromNetworkInternal();
+      if (result.isErr()) {
+        that.networkError = result;
+      } else {
+        that.networkData = result;
+      }
+      yield result;
+    })();
+  }
+  writeToCache(cache, networkResult) {
+    return this.writeToCacheInternal(cache, networkResult);
+  }
+}
+class CacheControlCommand extends BaseCommand {
+  constructor(services) {
+    super();
+    this.services = services;
+    this.keysUsed = /* @__PURE__ */ new Set();
+    this.keysUpdated = void 0;
+    this.operationType = "query";
+    this.lastResult = void 0;
+    this.unsubscribeFromKeysImpl = () => void 0;
+    this.subscriptions = [];
+    this.instantiationTime = Date.now() / 1e3;
+  }
+  execute(overrides) {
+    this.keysUpdated = void 0;
+    this.unsubscribeFromKeys();
+    const mergedCacheControlConfig = mergeCacheControlConfigs(
+      this.cacheControlStrategyConfig,
+      overrides
+    );
+    const requestRunner = this.buildRequestRunner();
+    const resultPromise = this.services.cacheController.execute(mergedCacheControlConfig, requestRunner, {
+      instrumentationAttributes: this.instrumentationAttributes
+    });
+    return resultPromise.then((result) => {
+      return this.handleCacheControllerResult(result, requestRunner).then((result2) => {
+        if (this.lastResult === void 0) {
+          if (result2.isErr()) {
+            this.lastResult = { type: "error", error: result2.error.failure };
+          } else {
+            this.lastResult = { type: "data", data: result2.value.data };
+          }
+        }
+        return result2;
+      });
+    });
+  }
+  handleCacheControllerResult(result, requestRunner) {
+    const { networkError, networkData, returnData } = requestRunner;
+    return this.publishUpdatedKeys().then(() => {
+      if (networkError) {
+        return buildSubscribableResult(
+          networkError,
+          this.buildSubscribe(),
+          () => this.refresh()
+        );
+      }
+      if (result.isErr()) {
+        if (networkData) {
+          return buildSubscribableResult(
+            networkData,
+            this.buildSubscribe(),
+            () => this.refresh()
+          );
+        }
+        return buildSubscribableResult(result, this.buildSubscribe(), () => this.refresh());
+      }
+      if (this.subscriptions.length > 0) {
+        this.subscribeToKeysUsed();
+      }
+      if (returnData === void 0) {
+        if (networkData) {
+          return buildSubscribableResult(
+            networkData,
+            this.buildSubscribe(),
+            () => this.refresh()
+          );
+        }
+        return buildSubscribableResult(
+          err(new Error("Cache miss after fetching from network")),
+          this.buildSubscribe(),
+          () => this.refresh()
+        );
+      }
+      return returnData;
+    });
+  }
+  buildRequestRunner() {
+    return new CacheControlRequestRunner(
+      (cache) => this.buildResultWithSubscribe(cache),
+      () => this.requestFromNetwork(),
+      (cache, networkResult) => this.writeToCacheAndRecordKeys(cache, networkResult)
+    );
+  }
+  publishUpdatedKeys() {
+    if (this.services.pubSub) {
+      if (this.keysUpdated !== void 0 && this.keysUpdated.size > 0) {
+        return this.services.pubSub.publish({
+          type: "cacheUpdate",
+          data: this.keysUpdated
+        });
+      }
+    }
+    return resolvedPromiseLike$2(void 0);
+  }
+  subscribeToKeysUsed() {
+    this.unsubscribeFromKeys();
+    const { pubSub } = this.services;
+    if (!pubSub) {
+      this.unsubscribeFromKeysImpl = () => void 0;
+      return;
+    }
+    const rebuildUnsubscribe = pubSub.subscribe({
+      type: "cacheUpdate",
+      predicate: (event) => setOverlaps(event.data, this.keysUsed),
+      callback: () => this.rerun({ now: this.instantiationTime }).then(() => void 0),
+      keys: this.keysUsed
+    });
+    const refreshUnsubscribe = pubSub.subscribe({
+      type: "cacheInvalidation",
+      predicate: (event) => setOverlaps(event.data, this.keysUsed),
+      callback: () => this.rerun().then(() => void 0),
+      keys: this.keysUsed
+    });
+    this.unsubscribeFromKeysImpl = () => {
+      rebuildUnsubscribe();
+      refreshUnsubscribe();
+    };
+    return;
+  }
+  unsubscribeFromKeys() {
+    this.unsubscribeFromKeysImpl();
+  }
+  // TODO: This should likely be abstract in v2.  For v1, provide default comparison logic.
+  equals(result1, result2) {
+    return deepEquals(result1, result2);
+  }
+  async afterRequestHooks(_options) {
+  }
+  refresh() {
+    return this.rerun({ cacheControlConfig: { type: "no-cache" } }).then((result) => {
+      if (result.isErr()) {
+        return err(result.error.failure);
+      }
+      return ok$1(void 0);
+    });
+  }
+  writeToCacheAndRecordKeys(cache, networkResult) {
+    const recordableCache = cache.record();
+    return this.writeToCache(recordableCache, networkResult).then((result) => {
+      this.instantiationTime = Date.now() / 1e3;
+      this.keysUpdated = recordableCache.keysUpdated;
+      return ok$1(result);
+    });
+  }
+  buildResultWithSubscribe(cache) {
+    const recordableCache = cache.record();
+    const result = this.readFromCache(recordableCache);
+    return result.then((readResult) => {
+      if (readResult.isErr()) {
+        return buildSubscribableResult(
+          readResult,
+          this.buildSubscribe(),
+          () => this.refresh()
+        );
+      } else {
+        const data = readResult.value;
+        this.keysUsed = recordableCache.keysRead;
+        return buildSubscribableResult(
+          ok$1(data),
+          this.buildSubscribe(),
+          () => this.refresh()
+        );
+      }
+    });
+  }
+  /**
+   * Builds a function that subscribes to cache changes via the pubsub service. Whenever
+   * relevant cache updates occur, it re-reads the data and compares it against
+   * the last known value. If a change is detected, the provided
+   * callback is invoked.
+   *
+   * @param keysRead - keys of interest that were read during readFromCache
+   * @returns an unsubscribe function to stop watching for updates
+   */
+  buildSubscribe() {
+    return (consumerCallback) => {
+      if (this.subscriptions.length === 0 && (this.operationType === "query" || this.operationType === "graphql")) {
+        this.subscribeToKeysUsed();
+      }
+      this.subscriptions.push(consumerCallback);
+      return () => {
+        this.subscriptions = this.subscriptions.filter((cb) => cb !== consumerCallback);
+        if (this.subscriptions.length === 0) {
+          this.unsubscribeFromKeys();
+        }
+      };
+    };
+  }
+  rerun(overrides) {
+    return this.execute(overrides).then((result) => {
+      if (result.isErr()) {
+        this.lastResult = { type: "error", error: result.error.failure };
+        this.invokeConsumerCallbacks(err(result.error.failure));
+        return result;
+      }
+      if (this.lastResult === void 0 || this.lastResult.type === "error" || !this.equals(this.lastResult.data, result.value.data)) {
+        this.lastResult = { type: "data", data: result.value.data };
+        this.invokeConsumerCallbacks(ok$1(result.value.data));
+      }
+      return result;
+    });
+  }
+  invokeConsumerCallbacks(data) {
+    this.subscriptions.forEach((cb) => {
+      try {
+        cb(data);
+      } catch (error) {
+      }
+    });
+  }
+}
+function mergeCacheControlConfigs(baseConfig, overrides) {
+  if (!overrides) {
+    return baseConfig;
+  }
+  const now = overrides.now ?? baseConfig.now;
+  if (!overrides.cacheControlConfig) {
+    return {
+      ...baseConfig,
+      now
+    };
+  }
+  return {
+    ...overrides.cacheControlConfig,
+    now
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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
+ */
+let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheControlCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+    this.actionConfig = {
+      background: false,
+      hotspot: true,
+      longRunning: false,
+      storable: false
+    };
+    this.networkPreference = "aura";
+  }
+  get fetchParams() {
+    throw new Error(
+      "Fetch parameters must be specified when using HTTP transport on an Aura adapter"
+    );
+  }
+  shouldUseAuraNetwork() {
+    return this.services.auraNetwork !== void 0 && (this.networkPreference === "aura" || !this.services.fetch);
+  }
+  shouldUseFetch() {
+    return this.services.fetch !== void 0 && (this.networkPreference === "http" || !this.services.auraNetwork);
+  }
+  requestFromNetwork() {
+    if (this.shouldUseAuraNetwork()) {
+      return this.convertAuraResponseToData(
+        this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig),
+        (errs) => this.coerceError(errs)
+      );
+    } else if (this.shouldUseFetch()) {
+      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+  }
+  coerceError(auraErrors) {
+    return toError(auraErrors[0]);
+  }
+  async coerceFetchError(errorResponse) {
+    return toError(errorResponse.statusText);
+  }
+  processAuraReturnValue(auraReturnValue) {
+    return ok$2(auraReturnValue);
+  }
+  processFetchReturnValue(json) {
+    return ok$2(json);
+  }
+  convertAuraResponseToData(responsePromise, coerceError) {
+    return responsePromise.then((response) => {
+      return this.processAuraReturnValue(response.getReturnValue());
+    }).finally(() => {
+      try {
+        this.afterRequestHooks({ statusCode: 200 });
+      } catch (e) {
+      }
+    }).catch((error) => {
+      if (!error || !error.getError) {
+        return err$1(toError("Failed to get error from response"));
+      } else {
+        const actionErrors = error.getError();
+        if (actionErrors.length > 0) {
+          return err$1(coerceError(actionErrors));
+        } else {
+          return err$1(toError("Error fetching component"));
+        }
+      }
+    });
+  }
+  convertFetchResponseToData(response) {
+    return response.then(
+      (response2) => {
+        if (response2.ok) {
+          return response2.json().then(
+            (json) => {
+              return this.processFetchReturnValue(json);
+            },
+            (reason) => err$1(toError(reason))
+          ).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        } else {
+          return this.coerceFetchError(response2).then((coercedError) => {
+            return err$1(coercedError);
+          }).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        }
+      },
+      (reason) => err$1(toError(reason))
+    );
+  }
+};
+class AuraResourceCacheControlCommand extends AuraCacheControlCommand$1 {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  readFromCache(cache) {
+    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$3(ok$2(data));
+  }
+  writeToCache(cache, networkResult) {
+    if (networkResult.isOk()) {
+      cache.set(this.buildKey(), {
+        value: networkResult.value,
+        metadata: {
+          cacheControl: this.buildCacheControlMetadata(networkResult.value)
+        }
+      });
+    }
+    return resolvedPromiseLike$3(void 0);
+  }
+  buildKey() {
+    return `{"endpoint":${this.endpoint},"params":${stableJSONStringify(this.auraParams)}}`;
+  }
+}
+function buildServiceDescriptor$h() {
+  return {
+    type: "auraResourceCacheControlCommand",
+    version: "1.0",
+    service: AuraResourceCacheControlCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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
+ */
+class AuraCacheControlCommand extends CacheControlCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+    this.actionConfig = {
+      background: false,
+      hotspot: true,
+      longRunning: false,
+      storable: false
+    };
+    this.networkPreference = "aura";
+  }
+  get fetchParams() {
+    throw new Error(
+      "Fetch parameters must be specified when using HTTP transport on an Aura adapter"
+    );
+  }
+  shouldUseAuraNetwork() {
+    return this.services.auraNetwork !== void 0 && (this.networkPreference === "aura" || !this.services.fetch);
+  }
+  shouldUseFetch() {
+    return this.services.fetch !== void 0 && (this.networkPreference === "http" || !this.services.auraNetwork);
+  }
+  requestFromNetwork() {
+    if (this.shouldUseAuraNetwork()) {
+      return this.convertAuraResponseToData(
+        this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig),
+        (errs) => this.coerceError(errs)
+      );
+    } else if (this.shouldUseFetch()) {
+      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+  }
+  coerceError(auraErrors) {
+    return toError(auraErrors[0]);
+  }
+  async coerceFetchError(errorResponse) {
+    return toError(errorResponse.statusText);
+  }
+  processAuraReturnValue(auraReturnValue) {
+    return ok$2(auraReturnValue);
+  }
+  processFetchReturnValue(json) {
+    return ok$2(json);
+  }
+  convertAuraResponseToData(responsePromise, coerceError) {
+    return responsePromise.then((response) => {
+      return this.processAuraReturnValue(response.getReturnValue());
+    }).finally(() => {
+      try {
+        this.afterRequestHooks({ statusCode: 200 });
+      } catch (e) {
+      }
+    }).catch((error) => {
+      if (!error || !error.getError) {
+        return err$1(toError("Failed to get error from response"));
+      } else {
+        const actionErrors = error.getError();
+        if (actionErrors.length > 0) {
+          return err$1(coerceError(actionErrors));
+        } else {
+          return err$1(toError("Error fetching component"));
+        }
+      }
+    });
+  }
+  convertFetchResponseToData(response) {
+    return response.then(
+      (response2) => {
+        if (response2.ok) {
+          return response2.json().then(
+            (json) => {
+              return this.processFetchReturnValue(json);
+            },
+            (reason) => err$1(toError(reason))
+          ).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        } else {
+          return this.coerceFetchError(response2).then((coercedError) => {
+            return err$1(coercedError);
+          }).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        }
+      },
+      (reason) => err$1(toError(reason))
+    );
+  }
+}
+class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  readFromCache(cache) {
+    const data = this.buildResultType().query(cache, this.buildQuery());
+    if (data.isErr()) {
+      return resolvedPromiseLike$3(
+        err$1(new Error(`Failed to build data from type: ${stringify$1(data.error)}`))
+      );
+    }
+    return resolvedPromiseLike$3(ok$2(data.value));
+  }
+  writeToCache(cache, networkResult) {
+    if (networkResult.isOk()) {
+      this.buildResultType().write(
+        cache.buildFixedTimeWritableCache(Date.now() / 1e3),
+        this.buildWriteInput(networkResult.value)
+      );
+    }
+    return resolvedPromiseLike$3(void 0);
+  }
+}
+function buildServiceDescriptor$g() {
+  return {
+    type: "auraNormalizedCacheControlCommand",
+    version: "1.0",
+    service: AuraNormalizedCacheControlCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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
+ */
+class HttpCacheControlCommand extends CacheControlCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  requestFromNetwork() {
+    return this.fetch();
+  }
+  fetch() {
+    return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+  }
+  async coerceError(errorResponse) {
+    return toError(errorResponse.statusText);
+  }
+  processFetchReturnValue(json) {
+    return ok$2(json);
+  }
+  convertFetchResponseToData(response) {
+    return response.then(
+      (response2) => {
+        if (response2.ok) {
+          return response2.json().then(
+            (json) => {
+              return this.processFetchReturnValue(json);
+            },
+            (reason) => err$1(toError(reason))
+          ).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        } else {
+          return this.coerceError(response2).then((coercedError) => {
+            return err$1(coercedError);
+          }).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        }
+      },
+      (reason) => err$1(toError(reason))
+    );
+  }
+}
+class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  readFromCache(cache) {
+    const data = this.buildResultType().query(cache, this.buildQuery());
+    if (data.isErr()) {
+      return resolvedPromiseLike$3(
+        err$1(new Error(`Failed to build data from type: ${stringify$1(data.error)}`))
+      );
+    }
+    return resolvedPromiseLike$3(ok$2(data.value));
+  }
+  writeToCache(cache, networkResult) {
+    if (networkResult.isOk()) {
+      this.buildResultType().write(
+        cache.buildFixedTimeWritableCache(Date.now() / 1e3),
+        this.buildWriteInput(networkResult.value)
+      );
+    }
+    return resolvedPromiseLike$3(void 0);
+  }
+}
+function buildServiceDescriptor$f() {
+  return {
+    type: "httpNormalizedCacheControlCommand",
+    version: "1.0",
+    service: HttpNormalizedCacheControlCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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
+ */
+class NetworkCommand extends BaseCommand {
+  constructor(services) {
+    super();
+    this.services = services;
+    this.subscriptions = [];
+    this.exposeSubscribeAndRefresh = false;
+  }
+  execute() {
+    const result = this.fetch();
+    if (this.exposeSubscribeAndRefresh) {
+      return this.fetchSubscribableResult(result);
+    }
+    return result;
+  }
+  fetchSubscribableResult(res) {
+    return res.then((networkResult) => {
+      return buildSubscribableResult$1(
+        networkResult,
+        (cb) => {
+          this.subscriptions.push(cb);
+          return () => {
+            this.subscriptions = this.subscriptions.filter((cb2) => cb2 !== cb);
+          };
+        },
+        () => this.refresh()
+      );
+    });
+  }
+  refresh() {
+    return this.execute().then((newResult) => {
+      if (isSubscribableResult(newResult)) {
+        const value = newResult.isOk() ? ok$2(newResult.value.data) : err$1(newResult.error.failure);
+        this.subscriptions.forEach((cb) => {
+          cb(value);
+        });
+      }
+      return ok$2(void 0);
+    });
+  }
+  async afterRequestHooks(_options) {
+  }
+}
+class FetchNetworkCommand extends NetworkCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  fetch() {
+    return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+  }
+  async coerceError(errorResponse) {
+    return toError(errorResponse.statusText);
+  }
+  convertFetchResponseToData(response) {
+    return response.then(
+      (response2) => {
+        if (response2.ok) {
+          return response2.json().then(
+            (json) => ok$2(json),
+            (reason) => err$1(toError(reason))
+          ).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        } else {
+          return this.coerceError(response2).then((coercedError) => {
+            return err$1(coercedError);
+          }).finally(() => {
+            try {
+              this.afterRequestHooks({ statusCode: response2.status });
+            } catch (e) {
+            }
+          });
+        }
+      },
+      (reason) => err$1(toError(reason))
+    );
+  }
+}
+function buildServiceDescriptor$e() {
+  return {
+    type: "fetchNetworkCommandBaseClass",
+    version: "1.0",
+    service: FetchNetworkCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class StreamingCommand extends BaseCommand {
+  constructor(services) {
+    super();
+    this.services = services;
+  }
+  execute() {
+    return this.convertFetchStreamResponseToData(this.services.fetch(...this.fetchParams));
+  }
+  convertFetchStreamResponseToData(response) {
+    return response.then(
+      (response2) => {
+        if (response2.ok && response2.body) {
+          return ok$2(this.decodeByteStream(response2.body));
+        } else {
+          return err$1(
+            toError(response2.ok ? "Response body not present" : response2.statusText)
+          );
+        }
+      },
+      (reason) => err$1(toError(reason))
+    );
+  }
+}
+function buildServiceDescriptor$d() {
+  return {
+    type: "streamingCommandBaseClass",
+    version: "1.0",
+    service: StreamingCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class SSECommand extends StreamingCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  /**
+   * Decodes the bytes returned by fetch into the correct shape.
+   *
+   * @param byteStream ReadableStream<Uint8Array> returned by fetch
+   * @returns ReadableStream<StreamedData> that will be the result of the Command
+   */
+  decodeByteStream(byteStream) {
+    return this.decodeSSEStream(
+      byteStream.pipeThrough(new TextDecoderStream()).pipeThrough(new SSEParsingStream())
+    );
+  }
+}
+const sseRegex = /^(?<field>[^:]*?)(: ?(?<value>.*?))?(?:\r\n?|\n)/;
+class SSEParsingStream extends TransformStream {
+  constructor() {
+    let ignoreLeadingLF = false, partialLine = "", data = "", event = "", id = "", retry;
+    super({
+      transform(chunk, controller) {
+        if (ignoreLeadingLF && chunk.startsWith("\n")) {
+          chunk = chunk.slice(1);
+        }
+        ignoreLeadingLF = chunk.endsWith("\r");
+        let text = partialLine + chunk;
+        let match;
+        while (match = text.match(sseRegex)) {
+          text = text.slice(match[0].length);
+          if (match.groups.field === "" && match.groups.value === void 0) {
+            if (data === "") {
+              event = "";
+              continue;
+            }
+            if (data.endsWith("\n")) {
+              data = data.slice(0, -1);
+            }
+            const sseMessage = {
+              data,
+              id,
+              // default event value is "message"
+              event: event || "message"
+            };
+            if (retry !== void 0) {
+              sseMessage.retry = retry;
+            }
+            controller.enqueue(sseMessage);
+            data = event = "";
+          } else if (match.groups.field === "data") {
+            data += (match.groups.value || "") + "\n";
+          } else if (match.groups.field === "event") {
+            event = match.groups.value || "";
+          } else if (match.groups.field === "id") {
+            const idValue = match.groups.value || "";
+            if (!idValue.includes("\0")) {
+              id = idValue;
+            }
+          } else if (match.groups.field === "retry") {
+            if (/^\d+$/.exec(match.groups.value)) {
+              retry = parseInt(match.groups.value);
+            }
+          } else ;
+        }
+        partialLine = text;
+      }
+    });
+  }
+}
+function buildServiceDescriptor$c() {
+  return {
+    type: "SSECommandBaseClass",
+    version: "1.0",
+    service: SSECommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function buildInstrumentCommand(services) {
+  const meter = services.instrumentation.metrics.getMeter("onestore");
+  return function instrumentCommand(commandClass, commandName) {
+    const invocationCounter = meter.createCounter(`${commandName}.command.invocation.count`);
+    const errorCounter = meter.createCounter(`${commandName}.command.error.count`);
+    const durationHistogram = meter.createHistogram(`${commandName}.command.duration`);
+    return class extends commandClass {
+      execute(...args) {
+        invocationCounter.add(1);
+        let result;
+        const start = services.instrumentation.currentTimeMs();
+        function recordDuration() {
+          const end = services.instrumentation.currentTimeMs();
+          durationHistogram.record(end - start);
+        }
+        try {
+          result = super.execute(...args);
+        } catch (e) {
+          errorCounter.add(1);
+          throw e;
+        }
+        if (typeof result === "object" && result !== null && "then" in result) {
+          result.then(recordDuration, () => {
+            errorCounter.add(1);
+          });
+        } else {
+          recordDuration();
+        }
+        return result;
+      }
+    };
+  };
+}
+function buildServiceDescriptor$b(instrumentation) {
+  return {
+    type: "instrumentCommand",
+    version: "1.0",
+    service: buildInstrumentCommand({ instrumentation })
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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
+ */
+class O11yOTelTraceAPI {
+  constructor(services) {
+    this.services = services;
+  }
+  getTracer(name, _version, _options) {
+    const o11yInstrumentation = getInstrumentation(name);
+    return new O11yTracer(o11yInstrumentation, this.services.logger);
+  }
+}
+class O11yTracer {
+  constructor(o11yInstrumentation, logger) {
+    this.o11yInstrumentation = o11yInstrumentation;
+    this.logger = logger;
+  }
+  startSpan(name, _options, context) {
+    const traceId = context == null ? void 0 : context.getValue(Symbol.for("traceId"));
+    const spanId = context == null ? void 0 : context.getValue(Symbol.for("spanId"));
+    const traceFlags = context == null ? void 0 : context.getValue(Symbol.for("traceFlags"));
+    let spanContext = void 0;
+    if (traceId !== void 0 && spanId !== void 0 && traceFlags !== void 0) {
+      spanContext = {
+        traceId,
+        spanId,
+        traceFlags
+      };
+    }
+    const activityOptions = spanContext === void 0 ? void 0 : {
+      instrumentationContext: {
+        rootId: spanContext.traceId,
+        isRootActivitySampled: spanContext.traceFlags === 1,
+        parentId: spanId
+      }
+    };
+    const activity = this.o11yInstrumentation.startActivity(name, activityOptions);
+    return new O11ySpan(activity, this.logger);
+  }
+  startActiveSpan(name, options, context, fn) {
+    let opts;
+    let ctx;
+    let fun;
+    if (typeof options === "function") {
+      fun = options;
+    } else {
+      opts = options;
+      if (typeof context === "function") {
+        fun = context;
+      } else {
+        ctx = context;
+        fun = fn;
+      }
+    }
+    const span = this.startSpan(name, opts, ctx);
+    return fun(span);
+  }
+}
+class O11ySpan {
+  constructor(activity, logger) {
+    this.activity = activity;
+    this.logger = logger;
+    this._isRecording = true;
+    this.attributes = {};
+  }
+  spanContext() {
+    return {
+      traceId: this.activity.getRootId(),
+      spanId: this.activity.getId(),
+      traceFlags: this.activity.getIsSampled() ? 1 : 0
+    };
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+    return this;
+  }
+  setAttributes(attributes) {
+    this.attributes = { ...this.attributes, ...attributes };
+    return this;
+  }
+  addEvent(_name, _attributesOrStartTime, _startTime) {
+    this.logger.warn("O11ySpan does not support addEvents.");
+    return this;
+  }
+  setStatus(_status) {
+    this.logger.warn("O11ySpan does not support setStatus.");
+    return this;
+  }
+  updateName(_name) {
+    this.logger.warn("O11ySpan does not support updateName.");
+    return this;
+  }
+  end(endTime) {
+    let endTimeInternal = endTime;
+    try {
+      if (typeof endTimeInternal !== "number") {
+        this.logger.warn("O11ySpan does not support non number endTime override.");
+        endTimeInternal = void 0;
+      }
+      this.activity.stop(
+        void 0,
+        void 0,
+        endTimeInternal ? { perfStopOverride: endTimeInternal } : void 0
+      );
+    } finally {
+      this._isRecording = false;
+    }
+    return;
+  }
+  isRecording() {
+    return this._isRecording;
+  }
+  recordException(exception, _time) {
+    this.activity.error(exception);
+  }
+}
+class O11yOTelMetricsAPI {
+  constructor(services) {
+    this.services = services;
+  }
+  getMeter(name, _version, __options) {
+    const o11yInstrumentation = getInstrumentation(name);
+    return new O11yMeter(o11yInstrumentation, this.services.logger);
+  }
+}
+class O11yMeter {
+  constructor(o11yInstrumentation, logger) {
+    this.o11yInstrumentation = o11yInstrumentation;
+    this.logger = logger;
+  }
+  createHistogram(name, _options) {
+    return new O11yHistogram(name, this.o11yInstrumentation, this.logger);
+  }
+  createCounter(name, options) {
+    if (options) {
+      this.logger.warn("counter options not supported in O11y instrumentation");
+    }
+    return new O11yCounter(name, this.o11yInstrumentation, this.logger);
+  }
+  createUpDownCounter(_name, _options) {
+    return new O11yUpDownCounter(this.logger);
+  }
+  createObservableGauge(_name, _options) {
+    return new O11yObservableGuage(this.logger);
+  }
+  createObservableCounter(_name, _options) {
+    return new O11yObservableCounter(this.logger);
+  }
+  createObservableUpDownCounter(_name, _options) {
+    return new O11yObservableUpDownCounter(this.logger);
+  }
+  addBatchObservableCallback(_callback, _observables) {
+    this.logger.warn("addBatchObservableCallback not supported yet");
+  }
+  removeBatchObservableCallback(_callback, _observables) {
+    this.logger.warn("removeBatchObservableCallback not supported yet");
+  }
+}
+class O11yCounter {
+  constructor(name, o11yInstrumentation, logger) {
+    this.name = name;
+    this.o11yInstrumentation = o11yInstrumentation;
+    this.logger = logger;
+  }
+  add(value, attributes, _context) {
+    if (value < 0) {
+      this.logger.warn(`Counter values must be non-negative. Got ${value}.`);
+      return;
+    }
+    this.o11yInstrumentation.incrementCounter(
+      this.name,
+      value,
+      void 0,
+      sanitizeAttributes(attributes)
+    );
+  }
+}
+class O11yHistogram {
+  constructor(name, o11yInstrumentation, logger) {
+    this.name = name;
+    this.o11yInstrumentation = o11yInstrumentation;
+    this.logger = logger;
+  }
+  record(value, attributes, _context) {
+    if (value < 0) {
+      this.logger.warn(`Histogram values must be non-negative. Got ${value}.`);
+      return;
+    }
+    this.o11yInstrumentation.trackValue(
+      this.name,
+      value,
+      void 0,
+      sanitizeAttributes(attributes)
+    );
+  }
+}
+class O11yUpDownCounter {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  add(_value, _attributes, _context) {
+    this.logger.warn("O11yUpDownCounter not supported yet.");
+  }
+}
+class O11yObservableCounter {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  addCallback(_callback) {
+    this.logger.warn("O11yObservableCounter not supported yet. Defaulting to noop.");
+  }
+  removeCallback(_callback) {
+    this.logger.warn("O11yObservableCounter not supported yet. Defaulting to noop.");
+  }
+}
+class O11yObservableGuage {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  addCallback(_callback) {
+    this.logger.warn("O11yObservableGuage not supported yet. Defaulting to noop.");
+  }
+  removeCallback(_callback) {
+    this.logger.warn("O11yObservableGuage not supported yet. Defaulting to noop.");
+  }
+}
+class O11yObservableUpDownCounter {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  addCallback(_callback) {
+    this.logger.warn("O11yObservableUpDownCounter not supported yet. Defaulting to noop.");
+  }
+  removeCallback(_callback) {
+    this.logger.warn("O11yObservableUpDownCounter not supported yet. Defaulting to noop.");
+  }
+}
+function sanitizeAttributes(attributes) {
+  if (!attributes) return;
+  const metricTags = {};
+  Object.entries(attributes).forEach(([key, value]) => {
+    if (value !== void 0 && !Array.isArray(value)) {
+      metricTags[key] = value;
+    }
+  });
+  return metricTags;
+}
+class O11yInstrumentation {
+  constructor(services) {
+    this.services = services;
+    this.currentTimeMs = () => performance.now();
+    this.trace = new O11yOTelTraceAPI(this.services);
+    this.metrics = new O11yOTelMetricsAPI(this.services);
+  }
+}
+function buildServiceDescriptor$a(logger) {
+  return {
+    type: "instrumentation",
+    version: "1.0",
+    service: new O11yInstrumentation({ logger })
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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
+ */
+const { stringify, parse } = JSON;
+function deepCopy(x) {
+  const stringified = stringify(x);
+  return stringified ? parse(stringified) : void 0;
+}
+class DefaultRecordableCache {
+  constructor(baseCache) {
+    this.baseCache = baseCache;
+    this.keysRead = /* @__PURE__ */ new Set();
+    this.missingKeysRead = /* @__PURE__ */ new Set();
+    this.keysUpdated = /* @__PURE__ */ new Set();
+    this.metadataKeysUpdated = /* @__PURE__ */ new Set();
+  }
+  delete(key) {
+    this.keysUpdated.add(key);
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    this.keysRead.add(key);
+    const value = this.baseCache.get(key);
+    if (value === void 0) {
+      this.missingKeysRead.add(key);
+    }
+    if (options == null ? void 0 : options.copy) {
+      return deepCopy(value);
+    }
+    return value;
+  }
+  set(key, value) {
+    this.keysUpdated.add(key);
+    this.metadataKeysUpdated.add(key);
+    this.baseCache.set(key, value);
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.metadataKeysUpdated.add(key);
+    this.baseCache.setMetadata(key, cacheControlMetadata);
+  }
+  length() {
+    return this.baseCache.length();
+  }
+  keys() {
+    return this.baseCache.keys();
+  }
+  entries() {
+    return this.baseCache.entries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class DefaultFilteredCache {
+  constructor(baseCache, predicate) {
+    this.baseCache = baseCache;
+    this.predicate = predicate;
+  }
+  delete(key) {
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    const result = this.baseCache.get(key);
+    if (result && this.predicate(key, result)) {
+      if (options == null ? void 0 : options.copy) {
+        return deepCopy(result);
+      }
+      return result;
+    }
+    return void 0;
+  }
+  set(key, value) {
+    this.baseCache.set(key, value);
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.baseCache.setMetadata(key, cacheControlMetadata);
+  }
+  length() {
+    return this.getFilteredKeys().size;
+  }
+  keys() {
+    return this.getFilteredKeys();
+  }
+  entries() {
+    return this.getFilteredEntries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  getFilteredEntries() {
+    return this.baseCache.entries().filter(([key, _value]) => {
+      return this.get(key);
+    });
+  }
+  getFilteredKeys() {
+    const filteredKeySet = /* @__PURE__ */ new Set();
+    this.baseCache.keys().forEach((key) => {
+      if (this.get(key)) {
+        filteredKeySet.add(key);
+      }
+    });
+    return filteredKeySet;
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class FixedTimeWritableCache {
+  constructor(baseCache, generatedTime) {
+    this.baseCache = baseCache;
+    this.generatedTime = generatedTime;
+  }
+  delete(key) {
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    return this.baseCache.get(key, options);
+  }
+  set(key, value) {
+    this.baseCache.set(key, {
+      ...value,
+      metadata: {
+        ...value.metadata,
+        cacheControl: { ...value.metadata.cacheControl, generatedTime: this.generatedTime }
+      }
+    });
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.baseCache.setMetadata(key, {
+      ...cacheControlMetadata,
+      generatedTime: this.generatedTime
+    });
+  }
+  length() {
+    return this.baseCache.length();
+  }
+  keys() {
+    return this.baseCache.keys();
+  }
+  entries() {
+    return this.baseCache.entries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class DefaultCache {
+  constructor() {
+    this.data = {};
+  }
+  get(key, options) {
+    if (options == null ? void 0 : options.copy) {
+      return deepCopy(this.data[key]);
+    }
+    return this.data[key];
+  }
+  /**
+   * Adds the specified key/value to the cache.
+   *
+   * @param key key at which to store value
+   * @param entry value to be stored
+   */
+  set(key, entry) {
+    if (entry.metadata.cacheControl.type === "no-store") {
+      return;
+    }
+    this.data[key] = {
+      ...entry,
+      metadata: {
+        ...entry.metadata,
+        type: entry.metadata.type || {
+          namespace: "OneStore:Internal",
+          name: "UnknownType"
+        },
+        cacheControl: {
+          generatedTime: Date.now() / 1e3,
+          ...entry.metadata.cacheControl
+        }
+      }
+    };
+  }
+  /**
+   * Removes the cache entry associated with the specified key.
+   *
+   * @param key key to be removed from the store
+   */
+  delete(key) {
+    delete this.data[key];
+  }
+  /**
+   * Sets the metadata for the specified key if the key is in cache.
+   * If the key doesn't exist, it does nothing.
+   *
+   * @param key key at which to store metadata
+   * @param cacheControlMetadata metadata to be stored
+   */
+  setMetadata(key, cacheControlMetadata) {
+    if (key in this.data) {
+      this.data[key].metadata.cacheControl = {
+        generatedTime: Date.now() / 1e3,
+        ...cacheControlMetadata
+      };
+    }
+  }
+  length() {
+    return this.keys().size;
+  }
+  keys() {
+    return new Set(Object.keys(this.data));
+  }
+  entries() {
+    return Object.entries(this.data);
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+function buildServiceDescriptor$9() {
+  return {
+    type: "cache",
+    version: "1.0",
+    service: new DefaultCache()
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class CacheControlStrategy {
+  constructor(services, config, requestRunner) {
+    this.services = services;
+    this.config = config;
+    this.requestRunner = requestRunner;
+    this.filteredCache = this.services.cache.filter((_, entry) => {
+      const { cacheControl } = entry.metadata;
+      return !this.expiredChecks.some((check) => check(cacheControl));
+    });
+  }
+  get expiredChecks() {
+    return [
+      (cacheControlMetadata) => cacheControlMetadata.type === "max-age" && this.config.now > cacheControlMetadata.generatedTime + cacheControlMetadata.maxAge,
+      (cacheControlMetadata) => cacheControlMetadata.type === "max-age" && cacheControlMetadata.maxAge <= 0,
+      (cacheControlMetadata) => cacheControlMetadata.type === "no-store",
+      (cacheControlMetadata) => cacheControlMetadata.type === "no-cache" && cacheControlMetadata.generatedTime < this.config.now
+    ];
+  }
+}
+class NoCacheCacheControlStrategy extends CacheControlStrategy {
+  execute() {
+    const tempCache = this.filteredCache;
+    return new Promise(async (resolve, reject) => {
+      try {
+        let readResult = ok$2(void 0);
+        for await (const rfnResult of this.requestRunner.requestFromNetwork()) {
+          if (rfnResult) {
+            const result = await this.services.cacheInclusionPolicy.write({
+              l1: tempCache,
+              writeToL1: (l1) => this.requestRunner.writeToCache(l1, rfnResult)
+            });
+            if (result.isErr()) {
+              return resolve(result);
+            }
+          }
+          readResult = await this.services.cacheInclusionPolicy.read({
+            l1: tempCache,
+            readFromL1: (l1) => this.requestRunner.readFromCache(l1)
+          });
+          if (readResult.isOk()) {
+            resolve(readResult);
+          }
+        }
+        return resolve(readResult);
+      } catch (error) {
+        return reject(error);
+      }
+    });
+  }
+}
+class MaxAgeCacheControlStrategy extends CacheControlStrategy {
+  execute(options) {
+    const startTime = this.services.instrumentation ? this.services.instrumentation.currentTimeMs() : 0;
+    return this.services.cacheInclusionPolicy.read({
+      l1: this.filteredCache,
+      readFromL1: (l1) => this.requestRunner.readFromCache(l1)
+    }).then((value) => {
+      if (value.isOk()) {
+        this.collectCacheHitInstrumentation(
+          startTime,
+          options == null ? void 0 : options.instrumentationAttributes
+        );
+        return ok$2(void 0);
+      }
+      this.collectCacheMissInstrumentation(startTime, options == null ? void 0 : options.instrumentationAttributes);
+      const tempCache = this.filteredCache;
+      return new Promise(async (resolve, reject) => {
+        try {
+          let readResult = ok$2(void 0);
+          for await (const rfnResult of this.requestRunner.requestFromNetwork()) {
+            if (rfnResult) {
+              const result = await this.services.cacheInclusionPolicy.write({
+                l1: tempCache,
+                writeToL1: (l1) => this.requestRunner.writeToCache(l1, rfnResult)
+              });
+              if (result.isErr()) {
+                return resolve(err$1(result.error));
+              }
+            }
+            readResult = await this.services.cacheInclusionPolicy.read({
+              l1: tempCache,
+              readFromL1: (l1) => this.requestRunner.readFromCache(l1)
+            });
+            if (readResult.isOk()) {
+              resolve(ok$2(void 0));
+            }
+          }
+          return resolve(readResult);
+        } catch (e) {
+          return reject(e);
+        }
+      });
+    });
+  }
+  collectCacheHitInstrumentation(startTime, instrumentationAttributes) {
+    if (this.services.instrumentation) {
+      const meter = this.services.instrumentation.metrics.getMeter("onestore");
+      meter.createCounter(`command.max-age.cache-hit.count`).add(1, instrumentationAttributes);
+      meter.createHistogram(`command.max-age.cache-hit.duration`).record(
+        this.services.instrumentation.currentTimeMs() - startTime,
+        instrumentationAttributes
+      );
+    }
+  }
+  collectCacheMissInstrumentation(startTime, instrumentationAttributes) {
+    if (this.services.instrumentation) {
+      const meter = this.services.instrumentation.metrics.getMeter("onestore");
+      meter.createCounter(`command.max-age.cache-miss.count`).add(1, instrumentationAttributes);
+      meter.createHistogram(`command.max-age.cache-miss.duration`).record(
+        this.services.instrumentation.currentTimeMs() - startTime,
+        instrumentationAttributes
+      );
+    }
+  }
+  get expiredChecks() {
+    const config = this.config;
+    return [
+      ...super.expiredChecks,
+      (cacheControlMetadata) => {
+        return cacheControlMetadata.generatedTime + config.requestMaxAge < config.now;
+      }
+    ];
+  }
+}
+class OnlyIfCachedCacheControlStrategy extends CacheControlStrategy {
+  execute(options) {
+    const startTime = this.services.instrumentation ? this.services.instrumentation.currentTimeMs() : 0;
+    return this.services.cacheInclusionPolicy.read({
+      l1: this.filteredCache,
+      readFromL1: (l1) => this.requestRunner.readFromCache(l1)
+    }).then((result) => {
+      if (result.isOk()) {
+        this.collectCacheHitInstrumentation(
+          startTime,
+          options == null ? void 0 : options.instrumentationAttributes
+        );
+        return ok$2(void 0);
+      }
+      this.collectCacheMissInstrumentation(startTime, options == null ? void 0 : options.instrumentationAttributes);
+      const error = new UserVisibleError(
+        new FetchResponse(HttpStatusCode.GatewayTimeout, {
+          error: "Cache miss for only-if-cached request"
+        })
+      );
+      return err$1(error);
+    });
+  }
+  get expiredChecks() {
+    return [
+      (cacheControlMetadata) => cacheControlMetadata.type === "no-store"
+    ];
+  }
+  collectCacheHitInstrumentation(startTime, instrumentationAttributes) {
+    if (this.services.instrumentation) {
+      const meter = this.services.instrumentation.metrics.getMeter("onestore");
+      meter.createCounter(`command.only-if-cached.cache-hit.count`).add(1, instrumentationAttributes);
+      meter.createHistogram(
+        `command.only-if-cached.cache-hit.duration`
+      ).record(
+        this.services.instrumentation.currentTimeMs() - startTime,
+        instrumentationAttributes
+      );
+    }
+  }
+  collectCacheMissInstrumentation(startTime, instrumentationAttributes) {
+    if (this.services.instrumentation) {
+      const meter = this.services.instrumentation.metrics.getMeter("onestore");
+      meter.createCounter(`command.only-if-cached.cache-miss.count`).add(1, instrumentationAttributes);
+      meter.createHistogram(
+        `command.only-if-cached.cache-miss.duration`
+      ).record(
+        this.services.instrumentation.currentTimeMs() - startTime,
+        instrumentationAttributes
+      );
+    }
+  }
+}
+class CacheController {
+  constructor(services) {
+    this.services = services;
+  }
+  execute(config, requestRunner, options) {
+    const strategy = this.getCacheControlStrategy(config, requestRunner);
+    return strategy.execute(options);
+  }
+  getCacheControlStrategy(config, requestRunner) {
+    if (config.type === "max-age") {
+      return new MaxAgeCacheControlStrategy(this.services, config, requestRunner);
+    } else if (config.type === "no-cache") {
+      return new NoCacheCacheControlStrategy(this.services, config, requestRunner);
+    } else if (config.type === "only-if-cached") {
+      return new OnlyIfCachedCacheControlStrategy(this.services, config, requestRunner);
+    }
+    throw new Error(`Unknown cache control strategy ${config.type}`);
+  }
+  /**
+   * Finds cache entries that match the given query.
+   * Returns an async generator that yields `[key, entry]`.
+   */
+  async *find(query) {
+    yield* this.services.cacheInclusionPolicy.find(query);
+  }
+  /**
+   * Finds and modifies cache entries that match the given query.
+   * Extends `find(query)` and returns an async generator of modified keys.
+   */
+  async *findAndModify(query, cacheUpdate) {
+    yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
+  }
+}
+function buildServiceDescriptor$8(cache, cacheInclusionPolicy) {
+  return {
+    type: "cacheController",
+    version: "1.0",
+    service: new CacheController({ cache, cacheInclusionPolicy })
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * 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() {
+    this.subscriptions = /* @__PURE__ */ new Map();
+  }
+  subscribe(subscription) {
+    let eventTypeSubscriptions = this.subscriptions.get(subscription.type);
+    if (eventTypeSubscriptions === void 0) {
+      eventTypeSubscriptions = [];
+      this.subscriptions.set(subscription.type, eventTypeSubscriptions);
+    }
+    eventTypeSubscriptions.push(subscription);
+    return () => {
+      this.subscriptions.set(
+        subscription.type,
+        this.subscriptions.get(subscription.type).filter((value) => value !== subscription)
+      );
+    };
+  }
+  publish(event) {
+    const promises = [];
+    const subscriptions = this.getSubscriptions(event);
+    subscriptions.forEach((subscription) => {
+      if (!this.getSubscriptions(event).includes(subscription)) {
+        return;
+      }
+      const returnVal = subscription.callback.call(subscription, event);
+      if (isPromiseLike$1(returnVal)) {
+        promises.push(returnVal);
+      }
+    });
+    if (promises.length > 0) {
+      return Promise.all(promises).then(() => void 0);
+    }
+    return resolvedPromiseLike$1(void 0);
+  }
+  getSubscriptions(event) {
+    const eventTypeSubscriptions = this.subscriptions.get(event.type);
+    const wildcardSubscriptions = this.subscriptions.get(EventTypeWildcard);
+    if (eventTypeSubscriptions === void 0 && wildcardSubscriptions === void 0) {
+      return [];
+    }
+    let matchingSubscriptions = [];
+    if (eventTypeSubscriptions !== void 0) {
+      matchingSubscriptions = eventTypeSubscriptions.filter((subscription) => {
+        if (subscription.predicate) {
+          return subscription.predicate(event);
+        }
+        return true;
+      });
+    }
+    matchingSubscriptions = [...matchingSubscriptions, ...wildcardSubscriptions || []];
+    return matchingSubscriptions;
+  }
+}
+function buildServiceDescriptor$7() {
+  return {
+    type: "pubSub",
+    version: "1.0",
+    service: new DefaultPubSubService()
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class CacheInclusionPolicyService {
+}
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+}
+const ok = (value) => new Ok(value);
+function resolvedPromiseLike(result) {
+  if (isPromiseLike(result)) {
+    return result.then((nextResult) => nextResult);
+  }
+  return {
+    then: (onFulfilled, _onRejected) => {
+      try {
+        return resolvedPromiseLike(onFulfilled(result));
+      } catch (e) {
+        if (onFulfilled === void 0) {
+          return resolvedPromiseLike(result);
+        }
+        return rejectedPromiseLike(e);
+      }
+    }
+  };
+}
+function rejectedPromiseLike(reason) {
+  if (isPromiseLike(reason)) {
+    return reason.then((nextResult) => nextResult);
+  }
+  return {
+    then: (_onFulfilled, onRejected) => {
+      if (typeof onRejected === "function") {
+        try {
+          return resolvedPromiseLike(onRejected(reason));
+        } catch (e) {
+          return rejectedPromiseLike(e);
+        }
+      }
+      return rejectedPromiseLike(reason);
+    }
+  };
+}
+function isPromiseLike(x) {
+  return typeof (x == null ? void 0 : x.then) === "function";
+}
+const isAndQuery = (query) => "$and" in query;
+const isOrQuery = (query) => "$or" in query;
+const isNotQuery = (query) => "$not" in query;
+const matchesMetadata = (metadataQuery, cacheControl) => {
+  if ("cacheControlType" in metadataQuery && cacheControl.type !== metadataQuery.cacheControlType.$eq) {
+    return false;
+  }
+  if ("maxAge" in metadataQuery && cacheControl.type === "max-age") {
+    const maxAge = cacheControl.maxAge ?? 0;
+    if (metadataQuery.maxAge.$gte !== void 0 && maxAge < metadataQuery.maxAge.$gte || metadataQuery.maxAge.$lte !== void 0 && maxAge > metadataQuery.maxAge.$lte) {
+      return false;
+    }
+  }
+  return true;
+};
+function queryToPredicate(query) {
+  return (key, entry) => {
+    if (!query) return false;
+    if (isAndQuery(query))
+      return query.$and.every((subQuery) => queryToPredicate(subQuery)(key, entry));
+    if (isOrQuery(query))
+      return query.$or.some((subQuery) => queryToPredicate(subQuery)(key, entry));
+    if (isNotQuery(query)) return !queryToPredicate(query.$not)(key, entry);
+    if ("key" in query) return matchesKey(query.key, key);
+    if ("metadata" in query)
+      return matchesMetadata(query.metadata, entry.metadata.cacheControl);
+    if ("value" in query) return false;
+    throw new Error("Unknown Query Operation");
+  };
+}
+function matchesKey(keyQuery, key) {
+  if ("$regex" in keyQuery) {
+    return keyQuery.$regex.test(key);
+  }
+  return false;
+}
+function buildUpdate(update, existing) {
+  switch (update.type) {
+    case "invalidate":
+      const updatedCacheControl = buildInvalidatedCacheControl(
+        existing.metadata.cacheControl
+      );
+      return updatedCacheControl !== void 0 ? { type: "metadata", metadata: updatedCacheControl } : { type: "no-op" };
+    default:
+      throw new Error(`Invalid update operation: ${update.type}`);
+  }
+}
+function buildInvalidatedCacheControl(existingCacheControl) {
+  switch (existingCacheControl.type) {
+    case "max-age":
+    case "stale-while-revalidate":
+      if (existingCacheControl.maxAge !== 0) {
+        return {
+          ...existingCacheControl,
+          maxAge: 0
+        };
+      }
+  }
+  return void 0;
+}
+class InMemoryCacheInclusionPolicy extends CacheInclusionPolicyService {
+  constructor(services) {
+    super();
+    this.services = services;
+  }
+  /**
+   * Reads data out of a single level in memory store.
+   */
+  read(options) {
+    const { l1, readFromL1 } = options;
+    return readFromL1(l1);
+  }
+  /**
+   * Writes data to a single level in memory store.
+   */
+  write(options) {
+    const { l1, writeToL1 } = options;
+    return writeToL1(l1);
+  }
+  /**
+   * Finds cache entries that match the given query.
+   * Returns an async generator that yields `[key, entry]`.
+   */
+  async *find(query) {
+    const cache = this.services.cache;
+    const predicate = queryToPredicate(query);
+    const filteredEntries = cache.filter(predicate).entries();
+    for (const entry of filteredEntries) {
+      yield entry;
+    }
+  }
+  /**
+   * Finds and modifies cache entries that match the given query.
+   * Extends `find(query)` and returns an async generator of modified keys.
+   */
+  async *findAndModify(query, cacheUpdate) {
+    const cache = this.services.cache;
+    for await (const [key, value] of this.find(query)) {
+      const update = buildUpdate(cacheUpdate, value);
+      switch (update.type) {
+        case "entry":
+          this.write({
+            l1: cache,
+            writeToL1: (l1) => resolvedPromiseLike(ok(l1.set(key, update.entry)))
+          });
+          yield key;
+          break;
+        case "metadata":
+          this.write({
+            l1: cache,
+            writeToL1: (l1) => resolvedPromiseLike(ok(l1.setMetadata(key, update.metadata)))
+          });
+          yield key;
+          break;
+      }
+    }
+  }
+}
+function buildInMemoryCacheInclusionPolicyService(cache) {
+  return {
+    service: new InMemoryCacheInclusionPolicy({ cache }),
+    type: "cacheInclusionPolicy",
+    version: "1.0"
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class FeatureFlagsService {
+  constructor() {
+    this.flags = /* @__PURE__ */ new Map();
+  }
+  set(flagName, value) {
+    this.flags.set(flagName, value);
+  }
+  get(flagName, defaultValue = false) {
+    return this.flags.get(flagName) || defaultValue;
+  }
+}
+function buildServiceDescriptor$6() {
+  return {
+    version: "1.0",
+    service: new FeatureFlagsService(),
+    type: "featureFlags"
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function devAssert(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message);
+  }
+}
+const MAX_ARRAY_LENGTH = 10;
+const MAX_RECURSIVE_DEPTH = 2;
+function inspect(value) {
+  return formatValue(value, []);
+}
+function formatValue(value, seenValues) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "function":
+      return value.name ? `[function ${value.name}]` : "[function]";
+    case "object":
+      return formatObjectValue(value, seenValues);
+    default:
+      return String(value);
+  }
+}
+function formatObjectValue(value, previouslySeenValues) {
+  if (value === null) {
+    return "null";
+  }
+  if (previouslySeenValues.includes(value)) {
+    return "[Circular]";
+  }
+  const seenValues = [...previouslySeenValues, value];
+  if (isJSONable(value)) {
+    const jsonValue = value.toJSON();
+    if (jsonValue !== value) {
+      return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+  return formatObject(value, seenValues);
+}
+function isJSONable(value) {
+  return typeof value.toJSON === "function";
+}
+function formatObject(object, seenValues) {
+  const entries = Object.entries(object);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[" + getObjectTag(object) + "]";
+  }
+  const properties = entries.map(
+    ([key, value]) => key + ": " + formatValue(value, seenValues)
+  );
+  return "{ " + properties.join(", ") + " }";
+}
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return "[]";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[Array]";
+  }
+  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  const remaining = array.length - len;
+  const items = [];
+  for (let i = 0; i < len; ++i) {
+    items.push(formatValue(array[i], seenValues));
+  }
+  if (remaining === 1) {
+    items.push("... 1 more item");
+  } else if (remaining > 1) {
+    items.push(`... ${remaining} more items`);
+  }
+  return "[" + items.join(", ") + "]";
+}
+function getObjectTag(object) {
+  const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
+  if (tag === "Object" && typeof object.constructor === "function") {
+    const name = object.constructor.name;
+    if (typeof name === "string" && name !== "") {
+      return name;
+    }
+  }
+  return tag;
+}
+globalThis.process && // eslint-disable-next-line no-undef
+process.env.NODE_ENV === "production";
+var Kind;
+(function(Kind2) {
+  Kind2["NAME"] = "Name";
+  Kind2["DOCUMENT"] = "Document";
+  Kind2["OPERATION_DEFINITION"] = "OperationDefinition";
+  Kind2["VARIABLE_DEFINITION"] = "VariableDefinition";
+  Kind2["SELECTION_SET"] = "SelectionSet";
+  Kind2["FIELD"] = "Field";
+  Kind2["ARGUMENT"] = "Argument";
+  Kind2["FRAGMENT_SPREAD"] = "FragmentSpread";
+  Kind2["INLINE_FRAGMENT"] = "InlineFragment";
+  Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition";
+  Kind2["VARIABLE"] = "Variable";
+  Kind2["INT"] = "IntValue";
+  Kind2["FLOAT"] = "FloatValue";
+  Kind2["STRING"] = "StringValue";
+  Kind2["BOOLEAN"] = "BooleanValue";
+  Kind2["NULL"] = "NullValue";
+  Kind2["ENUM"] = "EnumValue";
+  Kind2["LIST"] = "ListValue";
+  Kind2["OBJECT"] = "ObjectValue";
+  Kind2["OBJECT_FIELD"] = "ObjectField";
+  Kind2["DIRECTIVE"] = "Directive";
+  Kind2["NAMED_TYPE"] = "NamedType";
+  Kind2["LIST_TYPE"] = "ListType";
+  Kind2["NON_NULL_TYPE"] = "NonNullType";
+  Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition";
+  Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
+  Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
+  Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
+  Kind2["FIELD_DEFINITION"] = "FieldDefinition";
+  Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
+  Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
+  Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
+  Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
+  Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
+  Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
+  Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
+  Kind2["SCHEMA_EXTENSION"] = "SchemaExtension";
+  Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
+  Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
+  Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
+  Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
+  Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
+  Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
+})(Kind || (Kind = {}));
+var TokenKind;
+(function(TokenKind2) {
+  TokenKind2["SOF"] = "<SOF>";
+  TokenKind2["EOF"] = "<EOF>";
+  TokenKind2["BANG"] = "!";
+  TokenKind2["DOLLAR"] = "$";
+  TokenKind2["AMP"] = "&";
+  TokenKind2["PAREN_L"] = "(";
+  TokenKind2["PAREN_R"] = ")";
+  TokenKind2["SPREAD"] = "...";
+  TokenKind2["COLON"] = ":";
+  TokenKind2["EQUALS"] = "=";
+  TokenKind2["AT"] = "@";
+  TokenKind2["BRACKET_L"] = "[";
+  TokenKind2["BRACKET_R"] = "]";
+  TokenKind2["BRACE_L"] = "{";
+  TokenKind2["PIPE"] = "|";
+  TokenKind2["BRACE_R"] = "}";
+  TokenKind2["NAME"] = "Name";
+  TokenKind2["INT"] = "Int";
+  TokenKind2["FLOAT"] = "Float";
+  TokenKind2["STRING"] = "String";
+  TokenKind2["BLOCK_STRING"] = "BlockString";
+  TokenKind2["COMMENT"] = "Comment";
+})(TokenKind || (TokenKind = {}));
+const QueryDocumentKeys = {
+  Name: [],
+  Document: ["definitions"],
+  OperationDefinition: [
+    "name",
+    "variableDefinitions",
+    "directives",
+    "selectionSet"
+  ],
+  VariableDefinition: ["variable", "type", "defaultValue", "directives"],
+  Variable: ["name"],
+  SelectionSet: ["selections"],
+  Field: ["alias", "name", "arguments", "directives", "selectionSet"],
+  Argument: ["name", "value"],
+  FragmentSpread: ["name", "directives"],
+  InlineFragment: ["typeCondition", "directives", "selectionSet"],
+  FragmentDefinition: [
+    "name",
+    // Note: fragment variable definitions are deprecated and will removed in v17.0.0
+    "variableDefinitions",
+    "typeCondition",
+    "directives",
+    "selectionSet"
+  ],
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ["values"],
+  ObjectValue: ["fields"],
+  ObjectField: ["name", "value"],
+  Directive: ["name", "arguments"],
+  NamedType: ["name"],
+  ListType: ["type"],
+  NonNullType: ["type"],
+  SchemaDefinition: ["description", "directives", "operationTypes"],
+  OperationTypeDefinition: ["type"],
+  ScalarTypeDefinition: ["description", "name", "directives"],
+  ObjectTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  FieldDefinition: ["description", "name", "arguments", "type", "directives"],
+  InputValueDefinition: [
+    "description",
+    "name",
+    "type",
+    "defaultValue",
+    "directives"
+  ],
+  InterfaceTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  UnionTypeDefinition: ["description", "name", "directives", "types"],
+  EnumTypeDefinition: ["description", "name", "directives", "values"],
+  EnumValueDefinition: ["description", "name", "directives"],
+  InputObjectTypeDefinition: ["description", "name", "directives", "fields"],
+  DirectiveDefinition: ["description", "name", "arguments", "locations"],
+  SchemaExtension: ["directives", "operationTypes"],
+  ScalarTypeExtension: ["name", "directives"],
+  ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
+  InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
+  UnionTypeExtension: ["name", "directives", "types"],
+  EnumTypeExtension: ["name", "directives", "values"],
+  InputObjectTypeExtension: ["name", "directives", "fields"]
+};
+const kindValues = new Set(Object.keys(QueryDocumentKeys));
+function isNode(maybeNode) {
+  const maybeKind = maybeNode === null || maybeNode === void 0 ? void 0 : maybeNode.kind;
+  return typeof maybeKind === "string" && kindValues.has(maybeKind);
+}
+var OperationTypeNode;
+(function(OperationTypeNode2) {
+  OperationTypeNode2["QUERY"] = "query";
+  OperationTypeNode2["MUTATION"] = "mutation";
+  OperationTypeNode2["SUBSCRIPTION"] = "subscription";
+})(OperationTypeNode || (OperationTypeNode = {}));
+function isWhiteSpace(code) {
+  return code === 9 || code === 32;
+}
+function printBlockString(value, options) {
+  const escapedValue = value.replace(/"""/g, '\\"""');
+  const lines = escapedValue.split(/\r\n|[\n\r]/g);
+  const isSingleLine = lines.length === 1;
+  const forceLeadingNewLine = lines.length > 1 && lines.slice(1).every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0)));
+  const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""');
+  const hasTrailingQuote = value.endsWith('"') && !hasTrailingTripleQuotes;
+  const hasTrailingSlash = value.endsWith("\\");
+  const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
+  const printAsMultipleLines = !(options !== null && options !== void 0 && options.minimize) && // add leading and trailing new lines only if it improves readability
+  (!isSingleLine || value.length > 70 || forceTrailingNewline || forceLeadingNewLine || hasTrailingTripleQuotes);
+  let result = "";
+  const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0));
+  if (printAsMultipleLines && !skipLeadingNewLine || forceLeadingNewLine) {
+    result += "\n";
+  }
+  result += escapedValue;
+  if (printAsMultipleLines || forceTrailingNewline) {
+    result += "\n";
+  }
+  return '"""' + result + '"""';
+}
+var DirectiveLocation;
+(function(DirectiveLocation2) {
+  DirectiveLocation2["QUERY"] = "QUERY";
+  DirectiveLocation2["MUTATION"] = "MUTATION";
+  DirectiveLocation2["SUBSCRIPTION"] = "SUBSCRIPTION";
+  DirectiveLocation2["FIELD"] = "FIELD";
+  DirectiveLocation2["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION";
+  DirectiveLocation2["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD";
+  DirectiveLocation2["INLINE_FRAGMENT"] = "INLINE_FRAGMENT";
+  DirectiveLocation2["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION";
+  DirectiveLocation2["SCHEMA"] = "SCHEMA";
+  DirectiveLocation2["SCALAR"] = "SCALAR";
+  DirectiveLocation2["OBJECT"] = "OBJECT";
+  DirectiveLocation2["FIELD_DEFINITION"] = "FIELD_DEFINITION";
+  DirectiveLocation2["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION";
+  DirectiveLocation2["INTERFACE"] = "INTERFACE";
+  DirectiveLocation2["UNION"] = "UNION";
+  DirectiveLocation2["ENUM"] = "ENUM";
+  DirectiveLocation2["ENUM_VALUE"] = "ENUM_VALUE";
+  DirectiveLocation2["INPUT_OBJECT"] = "INPUT_OBJECT";
+  DirectiveLocation2["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
+})(DirectiveLocation || (DirectiveLocation = {}));
+function printString(str) {
+  return `"${str.replace(escapedRegExp, escapedReplacer)}"`;
+}
+const escapedRegExp = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
+function escapedReplacer(str) {
+  return escapeSequences[str.charCodeAt(0)];
+}
+const escapeSequences = [
+  "\\u0000",
+  "\\u0001",
+  "\\u0002",
+  "\\u0003",
+  "\\u0004",
+  "\\u0005",
+  "\\u0006",
+  "\\u0007",
+  "\\b",
+  "\\t",
+  "\\n",
+  "\\u000B",
+  "\\f",
+  "\\r",
+  "\\u000E",
+  "\\u000F",
+  "\\u0010",
+  "\\u0011",
+  "\\u0012",
+  "\\u0013",
+  "\\u0014",
+  "\\u0015",
+  "\\u0016",
+  "\\u0017",
+  "\\u0018",
+  "\\u0019",
+  "\\u001A",
+  "\\u001B",
+  "\\u001C",
+  "\\u001D",
+  "\\u001E",
+  "\\u001F",
+  "",
+  "",
+  '\\"',
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 2F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 3F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 4F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "\\\\",
+  "",
+  "",
+  "",
+  // 5F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 6F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "\\u007F",
+  "\\u0080",
+  "\\u0081",
+  "\\u0082",
+  "\\u0083",
+  "\\u0084",
+  "\\u0085",
+  "\\u0086",
+  "\\u0087",
+  "\\u0088",
+  "\\u0089",
+  "\\u008A",
+  "\\u008B",
+  "\\u008C",
+  "\\u008D",
+  "\\u008E",
+  "\\u008F",
+  "\\u0090",
+  "\\u0091",
+  "\\u0092",
+  "\\u0093",
+  "\\u0094",
+  "\\u0095",
+  "\\u0096",
+  "\\u0097",
+  "\\u0098",
+  "\\u0099",
+  "\\u009A",
+  "\\u009B",
+  "\\u009C",
+  "\\u009D",
+  "\\u009E",
+  "\\u009F"
+];
+const BREAK = Object.freeze({});
+function visit(root, visitor, visitorKeys = QueryDocumentKeys) {
+  const enterLeaveMap = /* @__PURE__ */ new Map();
+  for (const kind of Object.values(Kind)) {
+    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));
+  }
+  let stack = void 0;
+  let inArray = Array.isArray(root);
+  let keys = [root];
+  let index = -1;
+  let edits = [];
+  let node = root;
+  let key = void 0;
+  let parent = void 0;
+  const path = [];
+  const ancestors = [];
+  do {
+    index++;
+    const isLeaving = index === keys.length;
+    const isEdited = isLeaving && edits.length !== 0;
+    if (isLeaving) {
+      key = ancestors.length === 0 ? void 0 : path[path.length - 1];
+      node = parent;
+      parent = ancestors.pop();
+      if (isEdited) {
+        if (inArray) {
+          node = node.slice();
+          let editOffset = 0;
+          for (const [editKey, editValue] of edits) {
+            const arrayKey = editKey - editOffset;
+            if (editValue === null) {
+              node.splice(arrayKey, 1);
+              editOffset++;
+            } else {
+              node[arrayKey] = editValue;
+            }
+          }
+        } else {
+          node = { ...node };
+          for (const [editKey, editValue] of edits) {
+            node[editKey] = editValue;
+          }
+        }
+      }
+      index = stack.index;
+      keys = stack.keys;
+      edits = stack.edits;
+      inArray = stack.inArray;
+      stack = stack.prev;
+    } else if (parent) {
+      key = inArray ? index : keys[index];
+      node = parent[key];
+      if (node === null || node === void 0) {
+        continue;
+      }
+      path.push(key);
+    }
+    let result;
+    if (!Array.isArray(node)) {
+      var _enterLeaveMap$get, _enterLeaveMap$get2;
+      isNode(node) || devAssert(false, `Invalid AST Node: ${inspect(node)}.`);
+      const visitFn = isLeaving ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null || _enterLeaveMap$get === void 0 ? void 0 : _enterLeaveMap$get.leave : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null || _enterLeaveMap$get2 === void 0 ? void 0 : _enterLeaveMap$get2.enter;
+      result = visitFn === null || visitFn === void 0 ? void 0 : visitFn.call(visitor, node, key, parent, path, ancestors);
+      if (result === BREAK) {
+        break;
+      }
+      if (result === false) {
+        if (!isLeaving) {
+          path.pop();
+          continue;
+        }
+      } else if (result !== void 0) {
+        edits.push([key, result]);
+        if (!isLeaving) {
+          if (isNode(result)) {
+            node = result;
+          } else {
+            path.pop();
+            continue;
+          }
+        }
+      }
+    }
+    if (result === void 0 && isEdited) {
+      edits.push([key, node]);
+    }
+    if (isLeaving) {
+      path.pop();
+    } else {
+      var _node$kind;
+      stack = {
+        inArray,
+        index,
+        keys,
+        edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node);
+      keys = inArray ? node : (_node$kind = visitorKeys[node.kind]) !== null && _node$kind !== void 0 ? _node$kind : [];
+      index = -1;
+      edits = [];
+      if (parent) {
+        ancestors.push(parent);
+      }
+      parent = node;
+    }
+  } while (stack !== void 0);
+  if (edits.length !== 0) {
+    return edits[edits.length - 1][1];
+  }
+  return root;
+}
+function getEnterLeaveForKind(visitor, kind) {
+  const kindVisitor = visitor[kind];
+  if (typeof kindVisitor === "object") {
+    return kindVisitor;
+  } else if (typeof kindVisitor === "function") {
+    return {
+      enter: kindVisitor,
+      leave: void 0
+    };
+  }
+  return {
+    enter: visitor.enter,
+    leave: visitor.leave
+  };
+}
+function print(ast) {
+  return visit(ast, printDocASTReducer);
+}
+const MAX_LINE_LENGTH = 80;
+const printDocASTReducer = {
+  Name: {
+    leave: (node) => node.value
+  },
+  Variable: {
+    leave: (node) => "$" + node.name
+  },
+  // Document
+  Document: {
+    leave: (node) => join(node.definitions, "\n\n")
+  },
+  OperationDefinition: {
+    leave(node) {
+      const varDefs = wrap("(", join(node.variableDefinitions, ", "), ")");
+      const prefix = join(
+        [
+          node.operation,
+          join([node.name, varDefs]),
+          join(node.directives, " ")
+        ],
+        " "
+      );
+      return (prefix === "query" ? "" : prefix + " ") + node.selectionSet;
+    }
+  },
+  VariableDefinition: {
+    leave: ({ variable, type, defaultValue, directives }) => variable + ": " + type + wrap(" = ", defaultValue) + wrap(" ", join(directives, " "))
+  },
+  SelectionSet: {
+    leave: ({ selections }) => block(selections)
+  },
+  Field: {
+    leave({ alias, name, arguments: args, directives, selectionSet }) {
+      const prefix = wrap("", alias, ": ") + name;
+      let argsLine = prefix + wrap("(", join(args, ", "), ")");
+      if (argsLine.length > MAX_LINE_LENGTH) {
+        argsLine = prefix + wrap("(\n", indent(join(args, "\n")), "\n)");
+      }
+      return join([argsLine, join(directives, " "), selectionSet], " ");
+    }
+  },
+  Argument: {
+    leave: ({ name, value }) => name + ": " + value
+  },
+  // Fragments
+  FragmentSpread: {
+    leave: ({ name, directives }) => "..." + name + wrap(" ", join(directives, " "))
+  },
+  InlineFragment: {
+    leave: ({ typeCondition, directives, selectionSet }) => join(
+      [
+        "...",
+        wrap("on ", typeCondition),
+        join(directives, " "),
+        selectionSet
+      ],
+      " "
+    )
+  },
+  FragmentDefinition: {
+    leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => (
+      // or removed in the future.
+      `fragment ${name}${wrap("(", join(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap("", join(directives, " "), " ")}` + selectionSet
+    )
+  },
+  // Value
+  IntValue: {
+    leave: ({ value }) => value
+  },
+  FloatValue: {
+    leave: ({ value }) => value
+  },
+  StringValue: {
+    leave: ({ value, block: isBlockString }) => isBlockString ? printBlockString(value) : printString(value)
+  },
+  BooleanValue: {
+    leave: ({ value }) => value ? "true" : "false"
+  },
+  NullValue: {
+    leave: () => "null"
+  },
+  EnumValue: {
+    leave: ({ value }) => value
+  },
+  ListValue: {
+    leave: ({ values }) => "[" + join(values, ", ") + "]"
+  },
+  ObjectValue: {
+    leave: ({ fields }) => "{" + join(fields, ", ") + "}"
+  },
+  ObjectField: {
+    leave: ({ name, value }) => name + ": " + value
+  },
+  // Directive
+  Directive: {
+    leave: ({ name, arguments: args }) => "@" + name + wrap("(", join(args, ", "), ")")
+  },
+  // Type
+  NamedType: {
+    leave: ({ name }) => name
+  },
+  ListType: {
+    leave: ({ type }) => "[" + type + "]"
+  },
+  NonNullType: {
+    leave: ({ type }) => type + "!"
+  },
+  // Type System Definitions
+  SchemaDefinition: {
+    leave: ({ description, directives, operationTypes }) => wrap("", description, "\n") + join(["schema", join(directives, " "), block(operationTypes)], " ")
+  },
+  OperationTypeDefinition: {
+    leave: ({ operation, type }) => operation + ": " + type
+  },
+  ScalarTypeDefinition: {
+    leave: ({ description, name, directives }) => wrap("", description, "\n") + join(["scalar", name, join(directives, " ")], " ")
+  },
+  ObjectTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join(
+      [
+        "type",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  FieldDefinition: {
+    leave: ({ description, name, arguments: args, type, directives }) => wrap("", description, "\n") + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + ": " + type + wrap(" ", join(directives, " "))
+  },
+  InputValueDefinition: {
+    leave: ({ description, name, type, defaultValue, directives }) => wrap("", description, "\n") + join(
+      [name + ": " + type, wrap("= ", defaultValue), join(directives, " ")],
+      " "
+    )
+  },
+  InterfaceTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join(
+      [
+        "interface",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeDefinition: {
+    leave: ({ description, name, directives, types }) => wrap("", description, "\n") + join(
+      ["union", name, join(directives, " "), wrap("= ", join(types, " | "))],
+      " "
+    )
+  },
+  EnumTypeDefinition: {
+    leave: ({ description, name, directives, values }) => wrap("", description, "\n") + join(["enum", name, join(directives, " "), block(values)], " ")
+  },
+  EnumValueDefinition: {
+    leave: ({ description, name, directives }) => wrap("", description, "\n") + join([name, join(directives, " ")], " ")
+  },
+  InputObjectTypeDefinition: {
+    leave: ({ description, name, directives, fields }) => wrap("", description, "\n") + join(["input", name, join(directives, " "), block(fields)], " ")
+  },
+  DirectiveDefinition: {
+    leave: ({ description, name, arguments: args, repeatable, locations }) => wrap("", description, "\n") + "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join(locations, " | ")
+  },
+  SchemaExtension: {
+    leave: ({ directives, operationTypes }) => join(
+      ["extend schema", join(directives, " "), block(operationTypes)],
+      " "
+    )
+  },
+  ScalarTypeExtension: {
+    leave: ({ name, directives }) => join(["extend scalar", name, join(directives, " ")], " ")
+  },
+  ObjectTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) => join(
+      [
+        "extend type",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  InterfaceTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) => join(
+      [
+        "extend interface",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeExtension: {
+    leave: ({ name, directives, types }) => join(
+      [
+        "extend union",
+        name,
+        join(directives, " "),
+        wrap("= ", join(types, " | "))
+      ],
+      " "
+    )
+  },
+  EnumTypeExtension: {
+    leave: ({ name, directives, values }) => join(["extend enum", name, join(directives, " "), block(values)], " ")
+  },
+  InputObjectTypeExtension: {
+    leave: ({ name, directives, fields }) => join(["extend input", name, join(directives, " "), block(fields)], " ")
+  }
+};
+function join(maybeArray, separator = "") {
+  var _maybeArray$filter$jo;
+  return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter((x) => x).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : "";
+}
+function block(array) {
+  return wrap("{\n", indent(join(array, "\n")), "\n}");
+}
+function wrap(start, maybeString, end = "") {
+  return maybeString != null && maybeString !== "" ? start + maybeString + end : "";
+}
+function indent(str) {
+  return wrap("  ", str.replace(/\n/g, "\n  "));
+}
+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;
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function findExecutableOperation(input) {
+  const operations = input.query.definitions.filter(
+    (def) => def.kind === Kind.OPERATION_DEFINITION
+  );
+  if (operations.length === 0) {
+    return err$1(new Error("No operations found in query"));
+  }
+  if (operations.length === 1 && !input.operationName) {
+    return ok$2(operations[0]);
+  }
+  if (input.operationName) {
+    const specifiedOperation = operations.find((op) => {
+      var _a;
+      return ((_a = op.name) == null ? void 0 : _a.value) === input.operationName;
+    });
+    if (specifiedOperation) {
+      return ok$2(specifiedOperation);
+    }
+    return err$1(new Error(`Operation "${input.operationName}" not found in query`));
+  }
+  return err$1(new Error("Multiple operations found in query, and no operation name provided"));
+}
+function buildGraphQLInputExtension(input) {
+  const operationResult = findExecutableOperation(input);
+  if (operationResult.isErr()) {
+    return err$1(operationResult.error);
+  }
+  const operation = operationResult.value;
+  const selections = operation.selectionSet.selections;
+  const variableDefinitions = operation.variableDefinitions;
+  const variables = (variableDefinitions == null ? void 0 : variableDefinitions.reduce((prev, def) => {
+    var _a;
+    prev[def.variable.name.value] = {
+      definition: def,
+      value: (_a = input.variables) == null ? void 0 : _a[def.variable.name.value]
+    };
+    return prev;
+  }, {})) || {};
+  const fragments = input.query.definitions.filter(isFragmentDefinition).reduce((prev, fragment) => {
+    prev[fragment.name.value] = fragment;
+    return prev;
+  }, {});
+  return ok$2({
+    selections,
+    request: { definitions: { variables, fragments } },
+    parentFieldSelection: void 0
+  });
+}
+const TYPENAME_FIELD = {
+  kind: Kind.FIELD,
+  name: {
+    kind: Kind.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(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.OPERATION_DEFINITION;
+}
+function isField(node) {
+  return node.kind === Kind.FIELD;
+}
+function isFragmentDefinition(node) {
+  return node.kind === Kind.FRAGMENT_DEFINITION;
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheControlCommand {
+  constructor(config, documentRootType, services) {
+    super(services);
+    this.config = config;
+    this.documentRootType = documentRootType;
+    this.services = services;
+  }
+  buildResultType() {
+    return this.documentRootType;
+  }
+  buildQuery() {
+    const extensionResult = buildGraphQLInputExtension(this.config);
+    if (extensionResult.isErr()) {
+      throw extensionResult.error;
+    }
+    return {
+      type: "keyParams",
+      keyParams: null,
+      ...extensionResult.value
+    };
+  }
+  responseHasErrors(data) {
+    return data.hasOwnProperty("errors") && data.errors && data.errors.length > 0;
+  }
+  processAuraReturnValue(auraReturnValue) {
+    if (this.responseHasErrors(auraReturnValue)) {
+      return err$1(new UserVisibleError(auraReturnValue));
+    }
+    return ok$2(auraReturnValue);
+  }
+  processFetchReturnValue(json) {
+    if (this.responseHasErrors(json)) {
+      return err$1(new UserVisibleError(json));
+    }
+    return ok$2(json);
+  }
+  /**
+   * Optional body wrapper name for aura requests.
+   * If defined, the aura params will be wrapped in an object with this property name.
+   * Override this method in subclasses if a body wrapper is needed.
+   */
+  get auraBodyWrapperName() {
+    return void 0;
+  }
+  get auraParams() {
+    const params = { ...this.config, query: print(this.buildRequestQuery()) };
+    if (this.auraBodyWrapperName) {
+      return { [this.auraBodyWrapperName]: params };
+    }
+    return params;
+  }
+  get fetchParams() {
+    const body = { ...this.config, query: print(this.buildRequestQuery()) };
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const params = {
+      method: "POST",
+      cache: "no-cache",
+      headers,
+      body: JSON.stringify(body)
+    };
+    return [this.url, params];
+  }
+  get originalAuraParams() {
+    const params = { ...this.config, query: print(this.config.query) };
+    if (this.auraBodyWrapperName) {
+      return { [this.auraBodyWrapperName]: params };
+    }
+    return params;
+  }
+  get originalFetchParams() {
+    const body = { ...this.config, query: print(this.config.query) };
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const params = {
+      method: "POST",
+      cache: "no-cache",
+      headers,
+      body: JSON.stringify(body)
+    };
+    return [this.url, params];
+  }
+  // TODO: We should respect the cache control strategy in this method. We don't support only-if-cached strategies at the moment, but if we did add support, we would technically violate that cache control strategy if the data wasn't in the cache here.
+  runOriginalRequest() {
+    if (this.shouldUseAuraNetwork()) {
+      return this.convertAuraResponseToData(
+        this.services.auraNetwork(
+          this.endpoint,
+          this.originalAuraParams,
+          this.actionConfig
+        ),
+        (errs) => this.coerceError(errs)
+      ).then((result) => {
+        return buildSubscribableResult$1(result, this.buildSubscribe(), () => this.refresh());
+      });
+    } else if (this.shouldUseFetch()) {
+      return this.convertFetchResponseToData(
+        this.services.fetch(...this.originalFetchParams)
+      ).then((result) => {
+        return buildSubscribableResult$1(result, this.buildSubscribe(), () => this.refresh());
+      });
+    }
+    return resolvedPromiseLike$3(
+      buildSubscribableResult$1(
+        err$1(toError("Aura/Fetch network services not found")),
+        this.buildSubscribe(),
+        () => this.refresh()
+      )
+    );
+  }
+  buildRequestQuery() {
+    const augmentedQueryResult = this.documentRootType.buildAugmentedQuery(this.config);
+    if (augmentedQueryResult.isErr()) {
+      throw augmentedQueryResult.error;
+    }
+    return addTypenameToDocument(augmentedQueryResult.value);
+  }
+  buildWriteInput(data) {
+    const extensionResult = buildGraphQLInputExtension({
+      ...this.config,
+      query: this.buildRequestQuery()
+    });
+    if (extensionResult.isErr()) {
+      throw new InternalError(extensionResult.error);
+    }
+    return { data: data.data, ...extensionResult.value };
+  }
+  // Any changes to this method should most likely be duplicated in the https command as well
+  handleCacheControllerResult(result, requestRunner) {
+    const { networkError, returnData } = requestRunner;
+    return this.publishUpdatedKeys().then(() => {
+      if (networkError || returnData === void 0 || returnData.isErr() || result.isErr()) {
+        return this.runOriginalRequest();
+      }
+      if (this.subscriptions.length > 0) {
+        this.subscribeToKeysUsed();
+      }
+      return returnData;
+    });
+  }
+}
+function buildServiceDescriptor$5() {
+  return {
+    type: "auraGraphQLNormalizedCacheControlCommand",
+    version: "1.0",
+    service: AuraGraphQLNormalizedCacheControlCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheControlCommand {
+  constructor(config, documentRootType, services) {
+    super(services);
+    this.config = config;
+    this.documentRootType = documentRootType;
+    this.services = services;
+  }
+  buildResultType() {
+    return this.documentRootType;
+  }
+  buildQuery() {
+    const extensionResult = buildGraphQLInputExtension(this.config);
+    if (extensionResult.isErr()) {
+      throw extensionResult.error;
+    }
+    return {
+      type: "keyParams",
+      keyParams: null,
+      ...extensionResult.value
+    };
+  }
+  get fetchParams() {
+    const body = { ...this.config, query: print(this.buildRequestQuery()) };
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const params = {
+      method: "POST",
+      cache: "no-cache",
+      headers,
+      body: JSON.stringify(body)
+    };
+    return [this.url, params];
+  }
+  get originalFetchParams() {
+    const body = { ...this.config, query: print(this.config.query) };
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const params = {
+      method: "POST",
+      cache: "no-cache",
+      headers,
+      body: JSON.stringify(body)
+    };
+    return [this.url, params];
+  }
+  buildRequestQuery() {
+    const augmentedQueryResult = this.documentRootType.buildAugmentedQuery(this.config);
+    if (augmentedQueryResult.isErr()) {
+      throw augmentedQueryResult.error;
+    }
+    return addTypenameToDocument(augmentedQueryResult.value);
+  }
+  buildWriteInput(data) {
+    const extensionResult = buildGraphQLInputExtension({
+      ...this.config,
+      query: this.buildRequestQuery()
+    });
+    if (extensionResult.isErr()) {
+      throw new InternalError(extensionResult.error);
+    }
+    return { data: data.data, ...extensionResult.value };
+  }
+  processFetchReturnValue(json) {
+    if (json.hasOwnProperty("errors") && json.errors && json.errors.length > 0) {
+      return err$1(new UserVisibleError(json));
+    }
+    return ok$2(json);
+  }
+  runOriginalRequest() {
+    return this.convertFetchResponseToData(
+      this.services.fetch(...this.originalFetchParams)
+    ).then((result) => {
+      return buildSubscribableResult$1(result, this.buildSubscribe(), () => this.refresh());
+    });
+  }
+  // Any changes to this method should most likely be duplicated in the aura command as well
+  handleCacheControllerResult(result, requestRunner) {
+    const { networkError, returnData } = requestRunner;
+    return this.publishUpdatedKeys().then(() => {
+      if (networkError || returnData === void 0 || returnData.isErr() || result.isErr()) {
+        return this.runOriginalRequest();
+      }
+      if (this.subscriptions.length > 0) {
+        this.subscribeToKeysUsed();
+      }
+      return returnData;
+    });
+  }
+}
+function buildServiceDescriptor$4() {
+  return {
+    type: "httpGraphQLNormalizedCacheControlCommand",
+    version: "1.0",
+    service: HttpGraphQLNormalizedCacheControlCommand
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class NDJSONCommand extends StreamingCommand {
+  constructor(services) {
+    super(services);
+    this.services = services;
+  }
+  /**
+   * Decodes the bytes returned by fetch into the correct shape.
+   *
+   * @param byteStream ReadableStream<Uint8Array> returned by fetch
+   * @returns ReadableStream<T> that will be the result of the Command
+   */
+  decodeByteStream(byteStream) {
+    return this.decodeNDJSONStream(
+      byteStream.pipeThrough(new TextDecoderStream()).pipeThrough(new NDJSONParsingStream())
+    );
+  }
+}
+class NDJSONParsingStream extends TransformStream {
+  constructor() {
+    let partialLine = "";
+    super({
+      transform(chunk, controller) {
+        const text = partialLine + chunk;
+        const lines = text.split(/\r?\n/);
+        partialLine = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed === "") continue;
+          try {
+            const parsed = JSON.parse(trimmed);
+            controller.enqueue(parsed);
+          } catch (e) {
+            throw new Error(`Invalid NDJSON line: ${line}`);
+          }
+        }
+      },
+      flush(controller) {
+        const trimmed = partialLine.trim();
+        if (trimmed !== "") {
+          try {
+            const parsed = JSON.parse(trimmed);
+            controller.enqueue(parsed);
+          } catch (e) {
+            throw new Error(`Invalid NDJSON final line: ${partialLine}`);
+          }
+        }
+      }
+    });
+  }
+}
+function buildServiceDescriptor$3() {
+  return {
+    type: "NDJSONCommandBaseClass",
+    version: "1.0",
+    service: NDJSONCommand
+  };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+/**
+ * Creates a LuvioService descriptor with the provided Luvio instance.
+ * This function follows the standard service builder pattern used
+ * throughout the Luvio service ecosystem.
+ *
+ * @param luvio The Luvio engine instance to wrap in the service
+ * @returns A service descriptor that can be used in dependency injection
+ *
+ * @example
+ * ```typescript
+ * const luvioService = buildLuvioService(myLuvioInstance);
+ *
+ * // Use in a services object
+ * const services = {
+ *   ...otherServices,
+ *   luvio: luvioService.service,
+ * };
+ * ```
+ */
+function buildServiceDescriptor$2(luvio) {
+    return {
+        type: 'luvio',
+        version: '1.0',
+        service: {
+            luvio,
+        },
+    };
+}
+// version: 0.1.0-dev1-c978a7b010
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
+    return {
+        type: 'luvioUiapiRecords',
+        version: '1.0',
+        service: {
+            notifyRecordUpdateAvailable,
+            getNormalizedLuvioRecord,
+        },
+    };
+}
+// version: 0.1.0-dev1-c978a7b010
+
+/*!
+ * 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";
+/*!
+ * 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);
+  }
+  debug(message) {
+    this.log("DEBUG", message);
+  }
+  info(message) {
+    this.log("INFO", message);
+  }
+  warn(message) {
+    this.log("WARN", message);
+  }
+  error(message) {
+    this.log("ERROR", message);
+  }
+  log(level, message) {
+    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);
+}
+class JwtToken {
+  /**
+   * Create a new JwtToken.
+   *
+   * @param _token - The JWT string.
+   * @param _decodedInfo - The decoded information from the JWT.
+   * @param _extraInfo - Any additional information associated with the JWT.
+   */
+  constructor(_token, _decodedInfo, _extraInfo) {
+    this._token = _token;
+    this._decodedInfo = _decodedInfo;
+    this._extraInfo = _extraInfo;
+  }
+  /**
+   * Get the JWT string.
+   *
+   * @returns The JWT string.
+   */
+  get token() {
+    return this._token;
+  }
+  /**
+   * Get the additional information associated with the JWT.
+   *
+   * @returns The additional information.
+   */
+  get extraInfo() {
+    return this._extraInfo;
+  }
+  /**
+   * Get the decoded information from the JWT.
+   *
+   * @returns The decoded information.
+   */
+  get decodedInfo() {
+    return this._decodedInfo;
+  }
+  /**
+   * Get the remaining time in seconds until the JWT expires.
+   *
+   * @returns The remaining time in seconds.
+   */
+  get tokenRemainingSeconds() {
+    return this.decodedInfo.exp - Date.now() / 1e3;
+  }
+  /**
+   * Check if the JWT is expired.
+   *
+   * @returns True if the JWT is expired, false otherwise.
+   */
+  get isExpired() {
+    return this.tokenRemainingSeconds <= 0;
+  }
+}
+let defaultLogger = {
+  trace: () => {
+  },
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+if (process.env.NODE_ENV !== "production") {
+  defaultLogger = loggerService$1();
+}
+function computeDecodedInfo(token, defaultTokenTTLInSeconds, logger) {
+  const decodedInfo = o(token);
+  if (decodedInfo.exp === void 0) {
+    logger.warn(`"exp" claim is not present in the provided token.`);
+    decodedInfo.exp = Date.now() / 1e3 + defaultTokenTTLInSeconds;
+  }
+  return decodedInfo;
+}
+class JwtRepository {
+  /**
+   * @param limitInSeconds - Time in seconds before the token's expiry to notify observers.
+   * @param defaultTokenTTLInSeconds - Default token expiry time in seconds if "exp" claim is not present in token.
+   * @param logger - Logger for logging warnings and errors.
+   */
+  constructor(limitInSeconds = 5, defaultTokenTTLInSeconds = 120, logger = defaultLogger) {
+    this.limitInSeconds = limitInSeconds;
+    this.defaultTokenTTLInSeconds = defaultTokenTTLInSeconds;
+    this.logger = logger;
+    this.observers = [];
+  }
+  /**
+   * Get the current token.
+   */
+  get token() {
+    return this._token;
+  }
+  /**
+   * Set the current token.
+   *
+   * @param token - JWT token as a string.
+   * @param extraInfo - Optional extra information.
+   */
+  setToken(token, extraInfo) {
+    const decodedInfo = computeDecodedInfo(
+      token,
+      this.defaultTokenTTLInSeconds,
+      this.logger
+    );
+    this._token = new JwtToken(token, decodedInfo, extraInfo);
+    this.observeTokenExpiration();
+    return this._token;
+  }
+  /**
+   * Remove the current token.
+   */
+  removeToken() {
+    this._token = void 0;
+    this.clearTimeoutHandler();
+  }
+  /**
+   * Subscribe to the token nearing its expiration.
+   *
+   * @param cb - Callback function to execute when token is nearing expiration.
+   */
+  subscribeToTokenNearExpiration(cb) {
+    this.observers.push(cb);
+    this.observeTokenExpiration();
+    return () => {
+      this.observers = this.observers.filter((observer) => observer !== cb);
+    };
+  }
+  /**
+   * Clear the timeout handler.
+   */
+  clearTimeoutHandler() {
+    if (this.timeoutHandler !== void 0) {
+      clearTimeout(this.timeoutHandler);
+    }
+  }
+  /**
+   * Observe and handle token expiration.
+   */
+  observeTokenExpiration() {
+    this.clearTimeoutHandler();
+    if (this.observers.length === 0 || this.token === void 0) {
+      return;
+    }
+    this.timeoutHandler = setTimeout(
+      () => this.notifyTokenIsExpiring(),
+      this.computeTimeoutTimeInMs()
+    );
+  }
+  /**
+   * Compute the timeout time in milliseconds.
+   */
+  computeTimeoutTimeInMs() {
+    const remainingSeconds = this.token.tokenRemainingSeconds;
+    let timeoutTimeInSeconds = remainingSeconds - this.limitInSeconds;
+    return timeoutTimeInSeconds < 0 ? 0 : timeoutTimeInSeconds * 1e3;
+  }
+  /**
+   * Notify all observers that the token is expiring.
+   */
+  notifyTokenIsExpiring() {
+    this.observers.forEach((cb) => {
+      try {
+        cb.call(void 0, this.token);
+      } catch (e2) {
+        this.logger.error(e2.message);
+      }
+    });
+  }
+}
+class JwtManager {
+  /**
+   * Constructor for JwtManager class.
+   *
+   * @param {JwtRepository<T, ExtraInfo>} jwtRepository JwtRepository instance used for token management.
+   * @param {JwtResolver<ExtraInfo>} resolver JwtResolver instance used for token retrieval.
+   * @param {JwtManagerOptions} options JwtManagerOptions bag to customize behavior.
+   */
+  constructor(jwtRepository, resolver, options) {
+    this.jwtRepository = jwtRepository;
+    this.resolver = resolver;
+    if (options == null ? void 0 : options.keepTokenUpdated) {
+      jwtRepository.subscribeToTokenNearExpiration(() => this.refreshToken());
+    }
+  }
+  /**
+   * Method to get a JWT token.
+   * If there's a token request in progress, it will return the Promise of this request.
+   * If the current token is undefined or expired, it will initiate a token refresh.
+   * Otherwise, it will return the current token.
+   *
+   * @returns {JwtToken<T, ExtraInfo> | Promise<JwtToken<T, ExtraInfo>>} The current token or the Promise of a token request.
+   */
+  getJwt() {
+    if (this.inflightPromise) {
+      return this.inflightPromise;
+    }
+    const token = this.jwtRepository.token;
+    if (token === void 0 || token.isExpired) {
+      return this.refreshToken();
+    }
+    return token;
+  }
+  /**
+   * Method to refresh a JWT token.
+   * If a refresh request is already in progress, it will return the Promise of this request.
+   * Otherwise, it will start a new refresh request and return its Promise.
+   *
+   * @returns {Promise<JwtToken<T, ExtraInfo>>} Promise of the refreshed token.
+   */
+  refreshToken() {
+    if (this.inflightPromise === void 0) {
+      this.inflightPromise = new Promise((resolve, reject) => {
+        this.resolver.getJwt().then(({ jwt, extraInfo }) => {
+          this.inflightPromise = void 0;
+          const token = this.jwtRepository.setToken(jwt, extraInfo);
+          resolve(token);
+        }).catch((reason) => {
+          this.inflightPromise = void 0;
+          reject(reason);
+        });
+      });
+    }
+    return this.inflightPromise;
+  }
+  /**
+   * Method to check if a token refresh is in progress.
+   *
+   * @returns {boolean} true if a token refresh is in progress, false otherwise.
+   */
+  get isRefreshingToken() {
+    return this.inflightPromise !== void 0;
+  }
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function buildServiceDescriptor(interceptors = { request: [], response: [] }) {
+  return {
+    type: "fetch",
+    version: "1.0",
+    service: function(...args) {
+      const { request: requestInterceptors = [], response: responseInterceptors = [] } = interceptors;
+      const pending = requestInterceptors.reduce(
+        (previousPromise, interceptor) => previousPromise.then(interceptor),
+        resolvedPromiseLike$3(args)
+      );
+      return pending.then((args2) => fetch(...args2)).then((response) => {
+        return responseInterceptors.reduce(
+          (previousPromise, interceptor) => previousPromise.then(interceptor),
+          resolvedPromiseLike$3(response)
+        );
+      });
+    }
+  };
+}
+const UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE = "Unexpected Authorization header encountered. To specify a custom Authorization header, use a Fetch service that is not configured with JwtRequestHeaderInterceptor";
+function setHeaderAuthorization({ token }, [resource, options = {}]) {
+  let hasAuthorizationHeaderBeenSet = false;
+  const Authorization = `Bearer ${token}`;
+  if (resource instanceof Request && !(options == null ? void 0 : options.headers)) {
+    if (resource.headers.has("Authorization")) {
+      throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
+    }
+    resource.headers.set("Authorization", Authorization);
+    hasAuthorizationHeaderBeenSet = true;
+  }
+  if ((options == null ? void 0 : options.headers) instanceof Headers) {
+    if (options == null ? void 0 : options.headers.has("Authorization")) {
+      throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
+    }
+    options == null ? void 0 : options.headers.set("Authorization", Authorization);
+  } else {
+    if ((options == null ? void 0 : options.headers) && Reflect.has(options == null ? void 0 : options.headers, "Authorization")) {
+      throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
+    }
+    if (!hasAuthorizationHeaderBeenSet) {
+      options.headers = {
+        ...options == null ? void 0 : options.headers,
+        Authorization
+      };
+    }
+  }
+  return [resource, options];
+}
+function buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier = (_e, fetchArgs) => fetchArgs) {
+  return (args) => {
+    return resolvedPromiseLike$3(jwtManager.getJwt()).then((token) => {
+      const fetchArgsWithRequestHeaderAuthorization = setHeaderAuthorization(token, args);
+      return token.extraInfo ? jwtRequestModifier(token.extraInfo, fetchArgsWithRequestHeaderAuthorization) : fetchArgsWithRequestHeaderAuthorization;
+    });
+  };
+}
+
+/**
+ * Resolves Jwt token for SFAP by calling Aura action
+ * {@link JwtResolver} for platform SFAP
+ */
+const platformSfapJwtResolver = {
+    getJwt() {
+        return new Promise((resolve) => {
+            getSfapJwt().then((response) => {
+                resolve({
+                    jwt: response.jwt,
+                    extraInfo: {
+                        baseUri: response.baseUri,
+                    },
+                });
+            });
+        });
+    },
+};
+
+const METHODS_WITH_CSRF = ['POST', 'PATCH', 'PUT', 'DELETE'];
+/**
+ * Webruntime request interceptor that modifies outgoing HTTP requests with standard
+ * query parameters and security headers. This ensures the api calls for onestore adapters
+ * follow the same pattern as the equivalent luvio api calls for all CLWR endpoints.
+ *
+ * This interceptor:
+ * - Adds language query parameter from i18n settings
+ * - Adds asGuest parameter based on design/preview mode and SID cookie presence
+ * - Adds htmlEncode=false query parameter (since this is an api call by definition)
+ * - For POST/PATCH/PUT/DELETE requests, adds CSRF token to headers
+ *
+ * @param {FetchParameters} args - The fetch parameters array containing [url, requestInit]
+ * @returns Promise-like resolved with the modified fetch parameters
+ *
+ * @example
+ * ```typescript
+ * const modifiedArgs = await webruntimeRequestInterceptor(['/api/data', { method: 'GET' }]);
+ * // URL will have ?language=en_US&asGuest=false&htmlEncode=false appended
+ * ```
+ */
+async function webruntimeRequestInterceptor(args) {
+    const [url, requestInit] = args;
+    if (!(typeof url === 'string' || url instanceof URL)) {
+        return resolvedPromiseLike$3(args);
+    }
+    const urlObj = buildApiBaseUrl(url, apiBasePath);
+    urlObj.searchParams.append('language', language);
+    urlObj.searchParams.append('asGuest', getAsGuestParamValue().toString());
+    urlObj.searchParams.append('htmlEncode', 'false');
+    // Update the args array with the modified URL string
+    args[0] = urlObj;
+    if (requestInit?.method && METHODS_WITH_CSRF.includes(requestInit.method)) {
+        await addCSRFToken(requestInit);
+    }
+    return resolvedPromiseLike$3(args);
+}
+function buildApiBaseUrl(url, apiBasePath) {
+    // The URL constructor's second argument provides a base if the first argument is a relative URL.
+    const urlObj = new URL(url, location?.href);
+    // If a base path is provided, ensure the URL starts with it, otherwiswe prepend it to the path.
+    if (apiBasePath && !urlObj.pathname.startsWith(apiBasePath)) {
+        urlObj.pathname = apiBasePath + urlObj.pathname;
+    }
+    return urlObj;
+}
+function hasSidCookie() {
+    const cookies = document.cookie.split(';');
+    return cookies.some((cookie) => cookie.trim().startsWith(`${authenticationCookieName}=`));
+}
+function getAsGuestParamValue() {
+    // It's a guest user if not in design/preview mode AND the '__Secure-has-sid' cookie is missing.
+    // Note: `authenticationCookieName` (__Secure-has-sid) is *NOT* set in design/preview mode.
+    return !(isDesignMode || isPreviewMode) && !hasSidCookie();
+}
+async function addCSRFToken(params) {
+    const { csrfToken } = await getUser();
+    if (!params.headers) {
+        params.headers = {};
+    }
+    if (csrfToken) {
+        params.headers['CSRF-Token'] = csrfToken;
+    }
+}
+async function getUser() {
+    if (typeof window === 'undefined') {
+        // always make API calls as guest on the server
+        return { isGuest: true, id: null, csrfToken: null };
+    }
+    const { default: user } = await import('@app/user');
+    return user;
+}
+
+const SFAP_BASE_URL = 'api.salesforce.com';
+const sfapJwtRepository = new JwtRepository();
+const sfapJwtManager = new JwtManager(sfapJwtRepository, platformSfapJwtResolver);
+function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
+    const jwtAuthorizedFetchService = buildServiceDescriptor({
+        request: [buildJwtRequestInterceptor(logger)],
+    });
+    return {
+        ...jwtAuthorizedFetchService,
+        tags: { authenticationScopes: 'sfap_api' },
+    };
+}
+/**
+ * Returns a service descriptor for a fetch service that includes one-off copilot
+ * hacks. This fetch service is not intended for use by anything other than
+ * copilot commands.
+ */
+function buildCopilotFetchServiceDescriptor(logger) {
+    return {
+        // Note that this layers the Interceptor below directly on top of fetch(). WHen
+        // we switch to JWT authentication this will need to change to incorporate the
+        // Interceptor here with the logic in buildJwtAuthorizedSfapFetchServiceDescriptor()
+        // above.
+        ...buildServiceDescriptor({
+            request: [
+                // Note that this function is VERY closely tied to the fetchParams generated
+                // by copilotStartSessionCommand. Any changes to those parameters will require
+                // corresponding updates to the logic below.
+                (args) => {
+                    const [url, requestInit] = args;
+                    // ignore anything other than a start session request
+                    if (typeof url !== 'string' ||
+                        !url.endsWith('/sessions') ||
+                        !requestInit ||
+                        requestInit.method !== 'POST' ||
+                        !requestInit.body ||
+                        typeof requestInit.body !== 'string') {
+                        return resolvedPromiseLike$3(args);
+                    }
+                    return resolvedPromiseLike$3(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) {
+                            logger.warn('skipping injection of endpoint into start session request');
+                        }
+                        else {
+                            if (!body.instanceConfig) {
+                                body.instanceConfig = {};
+                            }
+                            body.instanceConfig.endpoint = token.decodedInfo.iss;
+                        }
+                        return [
+                            args[0],
+                            {
+                                ...args[1],
+                                body: JSON.stringify(body),
+                            },
+                        ];
+                    });
+                },
+                buildJwtRequestInterceptor(logger),
+            ],
+        }),
+        tags: { specialHacksFor: 'copilot' },
+    };
+}
+function buildDefaultFetchServiceDescriptor() {
+    const fetchService = buildServiceDescriptor({ request: [webruntimeRequestInterceptor] });
+    return {
+        ...fetchService,
+        tags: { authenticationScopes: '' },
+    };
+}
+function buildJwtRequestInterceptor(logger) {
+    const jwtRequestModifier = ({ baseUri }, [resource, request]) => {
+        if (typeof resource !== 'string' && !(resource instanceof URL)) {
+            // istanbul ignore else: this will not be tested in NODE_ENV = production for test coverage
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error('SFAP fetch service expects a string or URL resource');
+            }
+            return [resource, request];
+        }
+        const overrideUrl = new URL(baseUri);
+        const url = typeof resource === 'string' ? new URL(resource) : new URL(resource.toString());
+        if (!(url.host === SFAP_BASE_URL)) {
+            logger.warn(`SFAP fetch service requires that the host of the resource is ${SFAP_BASE_URL}`);
+            return [resource, request];
+        }
+        url.host = overrideUrl.host;
+        url.protocol = overrideUrl.protocol;
+        return [url, request];
+    };
+    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(sfapJwtManager, jwtRequestModifier);
+    return jwtRequestHeaderInterceptor;
+}
+
+const loggerService = new ConsoleLogger$1('ERROR');
+const cacheServiceDescriptor = buildServiceDescriptor$9();
+const instrumentationServiceDescriptor = buildServiceDescriptor$a(loggerService);
+const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
+const featureFlagsServiceDescriptor = buildServiceDescriptor$6();
+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
+featureFlagsService.set('useOneStoreGraphQL', false);
+const services = [
+    instrumentationServiceDescriptor,
+    buildDefaultFetchServiceDescriptor(),
+    buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
+    buildCopilotFetchServiceDescriptor(loggerService),
+    buildServiceDescriptor$b(instrumentationServiceDescriptor.service),
+    buildServiceDescriptor$8(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.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: 0.1.0-dev1-54c03dd38c