@salesforce/lds-runtime-aura 1.401.0 → 1.403.0

package/dist/ldsEngineCreator.js

@@ -26,21 +26,22 @@ import { GetApexWireAdapterFactory, registerPrefetcher as registerPrefetcher$1 }
 import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, coerceObjectIdArray, getObjectInfoAdapterFactory, coerceObjectId, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListInfoAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, getListInfoByNameAdapterFactory, getListInfosByObjectNameAdapterFactory, getListRecordsByNameAdapterFactory, getListObjectInfoAdapterFactory, getRelatedListsInfoAdapterFactory, getRelatedListActionsAdapterFactory, getRecordId18Array, buildRecordRepKeyFromId, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher, RecordRepresentationVersion } from 'force/ldsAdaptersUiapi';
 import { getInstrumentation } from 'o11y/client';
 import { findExecutableOperation, buildGraphQLInputExtension, addTypenameToDocument } from 'force/luvioGraphqlNormalization';
-import { print } from 'force/luvioOnestoreGraphqlParser';
+import { print, wrapConfigAndVerify, resolveAst, validateGraphQLOperations } from 'force/luvioOnestoreGraphqlParser';
 import { setServices } from 'force/luvioServiceProvisioner1';
+import { assertIsValid, MissingRequiredPropertyError, JsonSchemaViolationError } from 'force/luvioJsonschemaValidate5';
 import { dispatchGlobalEvent, unstable_loadComponentDefs, executeGlobalControllerRawResponse } from 'aura';
 import auraNetworkAdapter, { dispatchAuraAction, defaultActionConfig, instrument as instrument$1, forceRecordTransactionsDisabled as forceRecordTransactionsDisabled$1, ldsNetworkAdapterInstrument, CrudEventState, CrudEventType, UIAPI_RECORDS_PATH, UIAPI_RELATED_LIST_RECORDS_BATCH_PATH, UIAPI_RELATED_LIST_RECORDS_PATH } from 'force/ldsNetwork';
-import { pageScopedCache } from 'instrumentation/utility';
-import { instrument as instrument$2, generateRequestId, setupLexNetworkAdapter, internalRequestTracker } from 'force/ldsNetworkFetch';
 import { ThirdPartyTracker } from 'instrumentation:thirdPartyTracker';
+import { markStart, markEnd, counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
+import { instrument as instrument$2, setupLexNetworkAdapter, internalRequestTracker, generateRequestId as generateRequestId$1 } from 'force/ldsNetworkFetch';
 import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$3 } from 'force/ldsBindings';
-import { counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
-import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, logError, setLdsNetworkAdapterInstrumentation, incrementStateCreatedCount, executeAsyncActivity, METRIC_KEYS, onIdleDetected } from 'force/ldsInstrumentation';
+import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, logError as logError$2, setLdsNetworkAdapterInstrumentation, incrementStateCreatedCount, executeAsyncActivity, METRIC_KEYS, onIdleDetected } from 'force/ldsInstrumentation';
 import { instrument as instrument$4 } from 'force/adsBridge';
 import { instrument as instrument$5 } from '@lwc/state';
 import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
-import useHotspotLimit from '@salesforce/gate/lds.pdl.useHotspotLimit';
+import { pageScopedCache } from 'instrumentation/utility';
 import { createStorage, clearStorages } from 'force/ldsStorage';
+import useHotspotLimit from '@salesforce/gate/lds.pdl.useHotspotLimit';
 import useHttpUiapiOneApp from '@salesforce/gate/lds.useHttpUiapiOneApp';
 import useHttpUiapiOneRuntime from '@salesforce/gate/lds.useHttpUiapiOneRuntime';
 
@@ -52,14 +53,15 @@ import useHttpUiapiOneRuntime from '@salesforce/gate/lds.useHttpUiapiOneRuntime'
 const { create: create$1, freeze, keys: keys$2, entries: entries$1 } = Object;
 const { isArray: isArray$3 } = Array;
 const { stringify: stringify$3, parse: parse$2 } = JSON;
-const LogLevelMap$1 = {
+const WeakSetConstructor = WeakSet;
+const LogLevelMap = {
   TRACE: 4,
   DEBUG: 3,
   INFO: 2,
   WARN: 1,
   ERROR: 0
 };
-let ConsoleLogger$1 = class ConsoleLogger {
+class ConsoleLogger {
   constructor(level = "WARN", printer = console.log, formatter = (level2, message) => `${level2}: ${message}`) {
     this.level = level;
     this.printer = printer;
@@ -82,12 +84,15 @@ let ConsoleLogger$1 = class ConsoleLogger {
     this.log("ERROR", message);
   }
   log(level, message) {
-    if (LogLevelMap$1[level] > LogLevelMap$1[this.level]) {
+    if (LogLevelMap[level] > LogLevelMap[this.level]) {
       return;
     }
     this.printer(this.formatter(level, message));
   }
-};
+}
+function loggerService(level, printer, formatter) {
+  return new ConsoleLogger(level, printer, formatter);
+}
 let Ok$2 = class Ok {
   constructor(value) {
     this.value = value;
@@ -131,41 +136,41 @@ function buildSubscribableResult$1(result, subscribe, refresh) {
     return err$1({ failure: result.error, subscribe, refresh });
   }
 }
-function resolvedPromiseLike$3(result) {
-  if (isPromiseLike$3(result)) {
+function resolvedPromiseLike$2(result) {
+  if (isPromiseLike$2(result)) {
     return result.then((nextResult) => nextResult);
   }
   return {
     then: (onFulfilled, _onRejected) => {
       try {
-        return resolvedPromiseLike$3(onFulfilled(result));
+        return resolvedPromiseLike$2(onFulfilled(result));
       } catch (e) {
         if (onFulfilled === void 0) {
-          return resolvedPromiseLike$3(result);
+          return resolvedPromiseLike$2(result);
         }
-        return rejectedPromiseLike$3(e);
+        return rejectedPromiseLike$2(e);
       }
     }
   };
 }
-function rejectedPromiseLike$3(reason) {
-  if (isPromiseLike$3(reason)) {
+function rejectedPromiseLike$2(reason) {
+  if (isPromiseLike$2(reason)) {
     return reason.then((nextResult) => nextResult);
   }
   return {
     then: (_onFulfilled, onRejected) => {
       if (typeof onRejected === "function") {
         try {
-          return resolvedPromiseLike$3(onRejected(reason));
+          return resolvedPromiseLike$2(onRejected(reason));
         } catch (e) {
-          return rejectedPromiseLike$3(e);
+          return rejectedPromiseLike$2(e);
         }
       }
-      return rejectedPromiseLike$3(reason);
+      return rejectedPromiseLike$2(reason);
     }
   };
 }
-function isPromiseLike$3(x) {
+function isPromiseLike$2(x) {
   return typeof (x == null ? void 0 : x.then) === "function";
 }
 function stableJSONStringify$2(node) {
@@ -271,6 +276,24 @@ class FetchResponse extends Error {
     this.statusText = getStatusText(status);
   }
 }
+const deeplyFrozen = new WeakSetConstructor();
+function deepFreeze(value) {
+  if (typeof value !== "object" || value === null || deeplyFrozen.has(value)) {
+    return;
+  }
+  deeplyFrozen.add(value);
+  if (isArray$3(value)) {
+    for (let i = 0, len = value.length; i < len; i += 1) {
+      deepFreeze(value[i]);
+    }
+  } else {
+    const keys$1 = keys$2(value);
+    for (let i = 0, len = keys$1.length; i < len; i += 1) {
+      deepFreeze(value[keys$1[i]]);
+    }
+  }
+  freeze(value);
+}
 class InternalError extends Error {
   constructor(data) {
     super();
@@ -285,6 +308,15 @@ class UserVisibleError extends Error {
     this.type = "user-visible";
   }
 }
+function isUserVisibleError$1(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
+}
+function logError$1(error) {
+  if (isUserVisibleError$1(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -341,7 +373,7 @@ let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 };
-function buildServiceDescriptor$k() {
+function buildServiceDescriptor$r() {
   return {
     type: "networkCommandBaseClass",
     version: "1.0",
@@ -440,10 +472,10 @@ class AuraNetworkCommand extends NetworkCommand$1 {
     } else if (this.shouldUseFetch()) {
       return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
     }
-    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+    return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
 }
-function buildServiceDescriptor$j() {
+function buildServiceDescriptor$q() {
   return {
     type: "auraNetworkCommandBaseClass",
     version: "1.0",
@@ -493,41 +525,41 @@ function buildSubscribableResult(result, subscribe, refresh) {
     return err({ failure: result.error, subscribe, refresh });
   }
 }
-function resolvedPromiseLike$2(result) {
-  if (isPromiseLike$2(result)) {
+function resolvedPromiseLike$1(result) {
+  if (isPromiseLike$1(result)) {
     return result.then((nextResult) => nextResult);
   }
   return {
     then: (onFulfilled, _onRejected) => {
       try {
-        return resolvedPromiseLike$2(onFulfilled(result));
+        return resolvedPromiseLike$1(onFulfilled(result));
       } catch (e) {
         if (onFulfilled === void 0) {
-          return resolvedPromiseLike$2(result);
+          return resolvedPromiseLike$1(result);
         }
-        return rejectedPromiseLike$2(e);
+        return rejectedPromiseLike$1(e);
       }
     }
   };
 }
-function rejectedPromiseLike$2(reason) {
-  if (isPromiseLike$2(reason)) {
+function rejectedPromiseLike$1(reason) {
+  if (isPromiseLike$1(reason)) {
     return reason.then((nextResult) => nextResult);
   }
   return {
     then: (_onFulfilled, onRejected) => {
       if (typeof onRejected === "function") {
         try {
-          return resolvedPromiseLike$2(onRejected(reason));
+          return resolvedPromiseLike$1(onRejected(reason));
         } catch (e) {
-          return rejectedPromiseLike$2(e);
+          return rejectedPromiseLike$1(e);
         }
       }
-      return rejectedPromiseLike$2(reason);
+      return rejectedPromiseLike$1(reason);
     }
   };
 }
-function isPromiseLike$2(x) {
+function isPromiseLike$1(x) {
   return typeof (x == null ? void 0 : x.then) === "function";
 }
 function deepEquals$1(x, y) {
@@ -762,7 +794,7 @@ class CacheControlCommand extends BaseCommand {
         });
       }
     }
-    return resolvedPromiseLike$2(void 0);
+    return resolvedPromiseLike$1(void 0);
   }
   get operationType() {
     return "query";
@@ -1038,7 +1070,7 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
     } else if (this.shouldUseFetch()) {
       return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
     }
-    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+    return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
   coerceAuraErrors(auraErrors) {
     return toError(auraErrors[0]);
@@ -1112,9 +1144,9 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand$1 {
     var _a;
     const data = (_a = cache.get(this.buildKey())) == null ? void 0 : _a.value;
     if (data === void 0) {
-      return resolvedPromiseLike$3(err$1(new Error("Failed to find data in cache")));
+      return resolvedPromiseLike$2(err$1(new Error("Failed to find data in cache")));
     }
-    return resolvedPromiseLike$3(ok$2(data));
+    return resolvedPromiseLike$2(ok$2(data));
   }
   writeToCache(cache, networkResult) {
     if (networkResult.isOk()) {
@@ -1125,13 +1157,13 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand$1 {
         }
       });
     }
-    return resolvedPromiseLike$3(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
   buildKey() {
     return `{"endpoint":${this.endpoint},"params":${stableJSONStringify$2(this.auraParams)}}`;
   }
 }
-function buildServiceDescriptor$i() {
+function buildServiceDescriptor$p() {
   return {
     type: "auraResourceCacheControlCommand",
     version: "1.0",
@@ -1181,7 +1213,7 @@ class AuraCacheControlCommand extends CacheControlCommand {
     } else if (this.shouldUseFetch()) {
       return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
     }
-    return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
+    return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
   coerceAuraErrors(auraErrors) {
     return toError(auraErrors[0]);
@@ -1254,11 +1286,11 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
   readFromCache(cache) {
     const data = this.buildResultType().query(cache, this.buildQuery());
     if (data.isErr()) {
-      return resolvedPromiseLike$3(
+      return resolvedPromiseLike$2(
         err$1(new Error(`Failed to build data from type: ${stringify$3(data.error)}`))
       );
     }
-    return resolvedPromiseLike$3(ok$2(data.value));
+    return resolvedPromiseLike$2(ok$2(data.value));
   }
   writeToCache(cache, networkResult) {
     if (networkResult.isOk()) {
@@ -1267,10 +1299,10 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
         this.buildWriteInput(networkResult.value)
       );
     }
-    return resolvedPromiseLike$3(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
 }
-function buildServiceDescriptor$h() {
+function buildServiceDescriptor$o() {
   return {
     type: "auraNormalizedCacheControlCommand",
     version: "1.0",
@@ -1343,11 +1375,11 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
   readFromCache(cache) {
     const data = this.buildResultType().query(cache, this.buildQuery());
     if (data.isErr()) {
-      return resolvedPromiseLike$3(
+      return resolvedPromiseLike$2(
         err$1(new Error(`Failed to build data from type: ${stringify$3(data.error)}`))
       );
     }
-    return resolvedPromiseLike$3(ok$2(data.value));
+    return resolvedPromiseLike$2(ok$2(data.value));
   }
   writeToCache(cache, networkResult) {
     if (networkResult.isOk()) {
@@ -1356,10 +1388,10 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
         this.buildWriteInput(networkResult.value)
       );
     }
-    return resolvedPromiseLike$3(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
 }
-function buildServiceDescriptor$g() {
+function buildServiceDescriptor$n() {
   return {
     type: "httpNormalizedCacheControlCommand",
     version: "1.0",
@@ -1537,7 +1569,7 @@ _FetchNetworkCommand.availableDecorators = {
   abortable: createAbortableDecorator
 };
 let FetchNetworkCommand = _FetchNetworkCommand;
-function buildServiceDescriptor$f() {
+function buildServiceDescriptor$m() {
   return {
     type: "fetchNetworkCommandBaseClass",
     version: "1.0",
@@ -1573,7 +1605,7 @@ class StreamingCommand extends BaseCommand {
     );
   }
 }
-function buildServiceDescriptor$e() {
+function buildServiceDescriptor$l() {
   return {
     type: "streamingCommandBaseClass",
     version: "1.0",
@@ -1656,7 +1688,7 @@ class SSEParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$d() {
+function buildServiceDescriptor$k() {
   return {
     type: "SSECommandBaseClass",
     version: "1.0",
@@ -1707,7 +1739,7 @@ function buildInstrumentCommand(services) {
     };
   };
 }
-function buildServiceDescriptor$c(instrumentation) {
+function buildServiceDescriptor$j(instrumentation) {
   return {
     type: "instrumentCommand",
     version: "1.0",
@@ -1977,7 +2009,7 @@ class O11yInstrumentation {
     this.metrics = new O11yOTelMetricsAPI(this.services);
   }
 }
-function buildServiceDescriptor$b(logger) {
+function buildServiceDescriptor$i(logger) {
   return {
     type: "instrumentation",
     version: "1.0",
@@ -2230,7 +2262,7 @@ let DefaultCache$1 = class DefaultCache {
     return new FixedTimeWritableCache$1(this, generatedTime);
   }
 };
-function buildServiceDescriptor$a() {
+function buildServiceDescriptor$h() {
   return {
     type: "cache",
     version: "1.0",
@@ -2453,7 +2485,7 @@ class CacheController {
     yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
   }
 }
-function buildServiceDescriptor$9(cache, cacheInclusionPolicy, instrumentation) {
+function buildServiceDescriptor$g(cache, cacheInclusionPolicy, instrumentation) {
   return {
     type: "cacheController",
     version: "1.0",
@@ -2466,48 +2498,6 @@ function buildServiceDescriptor$9(cache, cacheInclusionPolicy, instrumentation)
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-function resolvedPromiseLike$1(result) {
-  if (isPromiseLike$1(result)) {
-    return result.then((nextResult) => nextResult);
-  }
-  return {
-    then: (onFulfilled, _onRejected) => {
-      try {
-        return resolvedPromiseLike$1(onFulfilled(result));
-      } catch (e) {
-        if (onFulfilled === void 0) {
-          return resolvedPromiseLike$1(result);
-        }
-        return rejectedPromiseLike$1(e);
-      }
-    }
-  };
-}
-function rejectedPromiseLike$1(reason) {
-  if (isPromiseLike$1(reason)) {
-    return reason.then((nextResult) => nextResult);
-  }
-  return {
-    then: (_onFulfilled, onRejected) => {
-      if (typeof onRejected === "function") {
-        try {
-          return resolvedPromiseLike$1(onRejected(reason));
-        } catch (e) {
-          return rejectedPromiseLike$1(e);
-        }
-      }
-      return rejectedPromiseLike$1(reason);
-    }
-  };
-}
-function isPromiseLike$1(x) {
-  return typeof (x == null ? void 0 : x.then) === "function";
-}
 const EventTypeWildcard = Symbol("EventTypeWildcard");
 class DefaultPubSubService {
   constructor() {
@@ -2535,14 +2525,14 @@ class DefaultPubSubService {
         return;
       }
       const returnVal = subscription.callback.call(subscription, event);
-      if (isPromiseLike$1(returnVal)) {
+      if (isPromiseLike$2(returnVal)) {
         promises.push(returnVal);
       }
     });
     if (promises.length > 0) {
       return Promise.all(promises).then(() => void 0);
     }
-    return resolvedPromiseLike$1(void 0);
+    return resolvedPromiseLike$2(void 0);
   }
   getSubscriptions(event) {
     const eventTypeSubscriptions = this.subscriptions.get(event.type);
@@ -2563,7 +2553,7 @@ class DefaultPubSubService {
     return matchingSubscriptions;
   }
 }
-function buildServiceDescriptor$8() {
+function buildServiceDescriptor$f() {
   return {
     type: "pubSub",
     version: "1.0",
@@ -2626,7 +2616,7 @@ class NDJSONParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$7() {
+function buildServiceDescriptor$e() {
   return {
     type: "NDJSONCommandBaseClass",
     version: "1.0",
@@ -2667,7 +2657,7 @@ function buildServiceDescriptor$7() {
  * };
  * ```
  */
-function buildServiceDescriptor$6(luvio) {
+function buildServiceDescriptor$d(luvio) {
     return {
         type: 'luvio',
         version: '1.0',
@@ -2676,7 +2666,7 @@ function buildServiceDescriptor$6(luvio) {
         },
     };
 }
-// version: 1.401.0-c620f9ffed
+// version: 1.403.0-5476a05446
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -2798,7 +2788,7 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
         return buildSubscribableResult$1(result, this.buildSubscribe(), () => this.refresh());
       });
     }
-    return resolvedPromiseLike$3(
+    return resolvedPromiseLike$2(
       buildSubscribableResult$1(
         err$1(toError("Aura/Fetch network services not found")),
         this.buildSubscribe(),
@@ -2840,7 +2830,7 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
     });
   }
 }
-function buildServiceDescriptor$5() {
+function buildServiceDescriptor$c() {
   return {
     type: "auraGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2958,7 +2948,7 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
     });
   }
 }
-function buildServiceDescriptor$4() {
+function buildServiceDescriptor$b() {
   return {
     type: "httpGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2982,7 +2972,7 @@ class FeatureFlagsService {
     return this.flags.get(flagName) || defaultValue;
   }
 }
-function buildServiceDescriptor$3() {
+function buildServiceDescriptor$a() {
   return {
     version: "1.0",
     service: new FeatureFlagsService(),
@@ -3004,7 +2994,7 @@ function buildServiceDescriptor$3() {
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-function buildServiceDescriptor$2(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
+function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
     return {
         type: 'luvioUiapiRecords',
         version: '1.0',
@@ -3014,7 +3004,7 @@ function buildServiceDescriptor$2(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.401.0-c620f9ffed
+// version: 1.403.0-5476a05446
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3037,9 +3027,12 @@ class RetryService {
       totalElapsedMs: Date.now() - startTime,
       lastResult: result
     };
-    while (policy.shouldRetry(result, context)) {
-      const delay = policy.calculateDelay(result, context);
+    while (await policy.shouldRetry(result, context)) {
+      const delay = await policy.calculateDelay(result, context);
       await this.delay(delay);
+      if (policy.prepareRetry) {
+        await policy.prepareRetry(result, context);
+      }
       attempt++;
       result = await operation();
       context = {
@@ -3058,7 +3051,109 @@ class RetryService {
 }
 class RetryPolicy {
 }
-function buildServiceDescriptor$1(defaultRetryPolicy) {
+class ComposedRetryPolicy extends RetryPolicy {
+  constructor(policies) {
+    super();
+    this.policies = policies;
+  }
+  /**
+   * Returns true if any of the composed policies want to retry.
+   *
+   * Uses OR logic: if ANY policy returns true, this returns true.
+   * Policies are checked in order and evaluation short-circuits on the first match.
+   */
+  async shouldRetry(result, context) {
+    for (const policy of this.policies) {
+      if (await policy.shouldRetry(result, context)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns the delay from the first policy that wants to retry.
+   *
+   * If multiple policies want to retry, only the FIRST policy's delay is used.
+   * Policy order in the constructor array determines priority.
+   * If no policy wants to retry, returns 0.
+   *
+   * @example
+   * ```typescript
+   * // If both PolicyA (1000ms) and PolicyB (5000ms) want to retry:
+   * const composed = new ComposedRetryPolicy([policyA, policyB]);
+   * composed.calculateDelay(result, context); // Returns 1000ms (PolicyA wins)
+   * ```
+   */
+  async calculateDelay(result, context) {
+    for (const policy of this.policies) {
+      if (await policy.shouldRetry(result, context)) {
+        return policy.calculateDelay(result, context);
+      }
+    }
+    return 0;
+  }
+  /**
+   * Calls prepareRetry on policies that both:
+   * 1. Implement the prepareRetry hook, AND
+   * 2. Returned true from shouldRetry for this result
+   *
+   * This allows only the matching policies to perform preparation work (e.g., token refresh).
+   * All matching prepareRetry calls run in parallel for efficiency.
+   *
+   * **Important**: prepareRetry only runs on policies that matched shouldRetry. This ensures
+   * you don't perform unnecessary work or side effects for unrelated retry conditions.
+   *
+   * **Note**: If multiple policies match and have prepareRetry, ensure they don't have
+   * conflicting side effects since they run in parallel.
+   *
+   * @example
+   * ```typescript
+   * // Status 401 occurs
+   * const composed = new ComposedRetryPolicy([
+   *   authPolicy,      // shouldRetry(401) → true, has prepareRetry
+   *   throttlePolicy,  // shouldRetry(401) → false, has prepareRetry
+   * ]);
+   *
+   * await composed.prepareRetry(result, context);
+   * // → Only authPolicy.prepareRetry() runs (because it matched)
+   * // → throttlePolicy.prepareRetry() does NOT run (didn't match)
+   * ```
+   */
+  async prepareRetry(result, context) {
+    const matchingPolicies = [];
+    for (const policy of this.policies) {
+      if (policy.prepareRetry !== void 0 && await policy.shouldRetry(result, context)) {
+        matchingPolicies.push(policy);
+      }
+    }
+    if (matchingPolicies.length > 0) {
+      await Promise.all(
+        matchingPolicies.map((policy) => policy.prepareRetry(result, context))
+      );
+    }
+  }
+  /**
+   * Returns all composed policies.
+   * Useful for accessing or configuring individual policies after composition.
+   */
+  getPolicies() {
+    return this.policies;
+  }
+  /**
+   * Helper to get a specific policy by type.
+   * Useful for calling policy-specific methods after composition.
+   *
+   * @example
+   * ```typescript
+   * const csrfPolicy = composedPolicy.getPolicyByType(CsrfTokenRetryPolicy);
+   * csrfPolicy?.setRequestContext(mutableRequest);
+   * ```
+   */
+  getPolicyByType(policyType) {
+    return this.policies.find((policy) => policy instanceof policyType);
+  }
+}
+function buildServiceDescriptor$8(defaultRetryPolicy) {
   return {
     version: "1.0",
     service: new RetryService(defaultRetryPolicy),
@@ -3071,898 +3166,1509 @@ function buildServiceDescriptor$1(defaultRetryPolicy) {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function e$1(e2) {
-  this.message = e2;
+function isUserVisibleError(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
 }
-e$1.prototype = new Error(), e$1.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$1("'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 throwUserlandError(error) {
+  logError(error);
+  throw buildUserlandError(error);
 }
-function n$1(e2) {
-  this.message = e2;
+function emitError(callback, error) {
+  logError(error);
+  callback({ data: void 0, error: buildUserlandError(error) });
 }
-function o(e2, r2) {
-  if ("string" != typeof e2) throw new n$1("Invalid token specified");
-  var o2 = true === (r2 = r2 || {}).header ? 0 : 1;
-  try {
-    return JSON.parse(t(e2.split(".")[o2]));
-  } catch (e3) {
-    throw new n$1("Invalid token specified: " + e3.message);
+function buildUserlandError(error) {
+  if (isUserVisibleError(error)) {
+    return error.data;
   }
+  return new Error("Internal error in Lightning Data Service adapter occurred.");
 }
-n$1.prototype = new Error(), n$1.prototype.name = "InvalidTokenError";
+function logError(error) {
+  if (isUserVisibleError(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
+
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-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);
+function buildBaseImperativeInvoker(getCommand, transformResult) {
+  return async (...params) => {
+    const command = getCommand({ params, assertIsValid });
+    try {
+      return command.execute().then((result) => transformResult(result));
+    } catch (error) {
+      throwUserlandError(error);
+    }
+  };
+}
+const supportedCachePolicyTypes = ["no-cache", "only-if-cached"];
+function requestContextIsSupportedCachePolicy(requestContext) {
+  return typeof requestContext === "object" && requestContext !== null && "cachePolicy" in requestContext && typeof requestContext.cachePolicy === "object" && requestContext.cachePolicy !== null && "type" in requestContext.cachePolicy && typeof requestContext.cachePolicy.type === "string" && supportedCachePolicyTypes.includes(
+    requestContext.cachePolicy.type
+  );
+}
+function getOverridesForLegacyRequestContext(requestContext) {
+  if (requestContextIsSupportedCachePolicy(requestContext)) {
+    return { cacheControlConfig: { type: requestContext.cachePolicy.type } };
   }
-  error(message) {
-    this.log("ERROR", message);
+  return {};
+}
+function handleEmit(res, callback) {
+  const consumerEmittedData = {
+    data: void 0,
+    errors: void 0
+  };
+  if (res.isOk()) {
+    consumerEmittedData.data = res.value.data;
+  } else {
+    const { data, errors } = toGraphQLResponseFromFailure$1(res.error);
+    consumerEmittedData.data = data;
+    consumerEmittedData.errors = errors;
   }
-  log(level, message) {
-    if (LogLevelMap[level] > LogLevelMap[this.level]) {
-      return;
-    }
-    this.printer(this.formatter(level, message));
+  callback(consumerEmittedData);
+}
+function toGraphQLResponseFromFailure$1(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
   }
+  logError$1(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
 }
-function loggerService(level, printer, formatter) {
-  return new ConsoleLogger(level, printer, formatter);
+class DefaultImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? result.value.data : result.value;
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
+  }
 }
-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;
-  }
+function buildServiceDescriptor$6() {
+  return {
+    type: "defaultImperativeBindings",
+    version: "1.0",
+    service: new DefaultImperativeBindingsService()
+  };
 }
-let defaultLogger = {
-  trace: () => {
-  },
-  debug: () => {
-  },
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
+class QueryImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? { data: result.value.data } : { data: result.value };
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
   }
-};
-if (process.env.NODE_ENV !== "production") {
-  defaultLogger = loggerService();
 }
-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;
+function buildServiceDescriptor$5() {
+  return {
+    type: "queryImperativeBindings",
+    version: "1.0",
+    service: new QueryImperativeBindingsService()
+  };
 }
-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
+class SubscribableImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return buildBaseImperativeInvoker(
+      getCommand,
+      (result) => this.transformResult(result, exposeRefresh)
     );
-    this._token = new JwtToken(token, decodedInfo, extraInfo);
-    this.observeTokenExpiration();
-    return this._token;
   }
-  /**
-   * Remove the current token.
-   */
-  removeToken() {
-    this._token = void 0;
-    this.clearTimeoutHandler();
+  transformResult(result, exposeRefresh = false) {
+    if (!isSubscribableResult(result)) {
+      console.error(
+        "Non-subscribable result encountered - please use correct operation type"
+      );
+      throw new Error("Internal error in Lightning Data Service adapter occurred");
+    }
+    if (result.isOk()) {
+      deepFreeze(result.value.data);
+      const api = {
+        data: result.value.data,
+        subscribe: (cb) => {
+          result.value.subscribe((result2) => {
+            if (result2.isErr()) {
+              return cb({ data: void 0, error: toError(result2.error) });
+            }
+            return cb({ data: result2.value, error: void 0 });
+          });
+        }
+      };
+      if (exposeRefresh) {
+        return {
+          ...api,
+          refresh: () => {
+            return result.value.refresh().then((res) => {
+              if (res.isOk()) {
+                return void 0;
+              }
+              throw res.error;
+            });
+          }
+        };
+      } else {
+        return api;
+      }
+    } else {
+      throw toError(result.error.failure);
+    }
   }
-  /**
-   * 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);
+}
+function buildServiceDescriptor$4() {
+  return {
+    type: "subscribableImperativeBindings",
+    version: "1.0",
+    service: new SubscribableImperativeBindingsService()
+  };
+}
+class LegacyImperativeBindingsService {
+  bind(getCommand) {
+    const invoke = async (config, requestContext, callback) => {
+      const command = getCommand({ config, assertIsValid });
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        const result = await command.execute(overrides);
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          callback({ data: result.value.data, error: void 0 });
+        } else {
+          callback({ data: void 0, error: toError(result.error.failure) });
+        }
+      } catch (error) {
+        emitError(callback, error);
+      }
+    };
+    const subscribe = (config, requestContext, callback) => {
+      const command = getCommand({ config, assertIsValid });
+      let unsubscribe = () => {
+      };
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        command.execute(overrides).then(
+          (result) => {
+            if (!result.isOk()) {
+              callback({ data: void 0, error: toError(result.error.failure) });
+              return;
+            }
+            unsubscribe = result.value.subscribe((res) => {
+              if (res.isOk()) {
+                callback({ data: res.value, error: void 0 });
+              } else {
+                callback({ data: void 0, error: toError(res.error) });
+              }
+            });
+            callback({ data: result.value.data, error: void 0 });
+          },
+          (e) => {
+            emitError(callback, e);
+          }
+        );
+      } catch (e) {
+        emitError(callback, e);
+      }
+      return () => {
+        unsubscribe();
+      };
     };
+    return { invoke, subscribe };
   }
-  /**
-   * Clear the timeout handler.
-   */
-  clearTimeoutHandler() {
-    if (this.timeoutHandler !== void 0) {
-      clearTimeout(this.timeoutHandler);
-    }
+}
+function buildServiceDescriptor$3() {
+  return {
+    type: "legacyImperativeBindings",
+    version: "1.0",
+    service: new LegacyImperativeBindingsService()
+  };
+}
+class GraphQLImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return async (...params) => {
+      try {
+        if (params.length) {
+          params[0] = wrapConfigAndVerify(params[0]);
+        }
+        return await buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);
+      } catch (error) {
+        logError$1(error);
+        return {
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        };
+      }
+    };
   }
-  /**
-   * Observe and handle token expiration.
-   */
-  observeTokenExpiration() {
-    this.clearTimeoutHandler();
-    if (this.observers.length === 0 || this.token === void 0) {
-      return;
+  transformResult(result, exposeRefresh = false) {
+    const consumerEmittedData = {
+      data: void 0,
+      errors: void 0
+    };
+    if (result.isOk()) {
+      deepFreeze(result.value);
+      consumerEmittedData.data = result.value.data.data;
+      consumerEmittedData.subscribe = (cb) => {
+        result.value.subscribe((res) => {
+          const consumerEmittedData2 = {
+            data: void 0,
+            errors: void 0
+          };
+          if (res.isOk()) {
+            consumerEmittedData2.data = res.value.data;
+          } else {
+            if (isUserVisibleError$1(res.error)) {
+              consumerEmittedData2.data = res.error.data.data;
+              consumerEmittedData2.errors = res.error.data.errors;
+            } else {
+              logError$1(res.error);
+              consumerEmittedData2.errors = [
+                {
+                  message: "Internal error in GraphQL adapter occurred",
+                  locations: []
+                }
+              ];
+            }
+          }
+          cb(consumerEmittedData2);
+        });
+      };
+      if (exposeRefresh) {
+        consumerEmittedData.refresh = () => {
+          return new Promise((resolve, reject) => {
+            try {
+              result.value.refresh().then((res) => {
+                if (res.isOk()) {
+                  resolve();
+                } else {
+                  reject(
+                    new Error(
+                      "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                    )
+                  );
+                }
+              });
+            } catch (error) {
+              logError$1(error);
+              reject(
+                new Error(
+                  "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                )
+              );
+            }
+          });
+        };
+      }
+    } else {
+      const resp = toGraphQLResponseFromFailure$1(result.error.failure);
+      consumerEmittedData.data = resp.data;
+      consumerEmittedData.errors = resp.errors;
     }
-    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;
+    return consumerEmittedData;
   }
-  /**
-   * Notify all observers that the token is expiring.
-   */
-  notifyTokenIsExpiring() {
-    this.observers.forEach((cb) => {
+}
+function buildServiceDescriptor$2$1() {
+  return {
+    type: "graphQLImperativeBindings",
+    version: "1.0",
+    service: new GraphQLImperativeBindingsService()
+  };
+}
+class GraphQLLegacyImperativeBindingsService {
+  bind(getCommand) {
+    const invoke = async (config, requestContext, callback) => {
+      config = wrapConfigAndVerify(config);
+      const command = getCommand({ config, assertIsValid });
       try {
-        cb.call(void 0, this.token);
-      } catch (e2) {
-        this.logger.error(e2.message);
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        const result = await command.execute(overrides);
+        const consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          consumerEmittedData.data = result.value.data.data;
+        } else {
+          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
+          consumerEmittedData.data = data;
+          consumerEmittedData.errors = errors;
+        }
+        callback(consumerEmittedData);
+      } catch (error) {
+        logError$1(error);
+        callback({
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        });
       }
-    });
+    };
+    const subscribe = (config, requestContext, callback) => {
+      config = wrapConfigAndVerify(config);
+      const command = getCommand({ config, assertIsValid });
+      let unsubscribe = () => {
+      };
+      const overrides = getOverridesForLegacyRequestContext(requestContext);
+      command.execute(overrides).then((result) => {
+        const consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          consumerEmittedData.data = result.value.data.data;
+          unsubscribe = result.value.subscribe(
+            (res) => {
+              handleEmit(res, callback);
+            }
+          );
+        } else {
+          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
+          consumerEmittedData.data = data;
+          consumerEmittedData.errors = errors;
+          unsubscribe = result.error.subscribe(
+            (res) => {
+              handleEmit(res, callback);
+            }
+          );
+        }
+        callback(consumerEmittedData);
+      });
+      return () => {
+        unsubscribe();
+      };
+    };
+    return { invoke, subscribe };
   }
 }
-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;
+function buildServiceDescriptor$1$1() {
+  return {
+    type: "graphQLLegacyImperativeBindings",
+    version: "1.0",
+    service: new GraphQLLegacyImperativeBindingsService()
+  };
+}
+class GraphQLMutationBindingsService {
+  bind(getCommand) {
+    return async (...params) => {
+      try {
+        if (params.length) {
+          params[0] = wrapConfigAndVerify(params[0], {
+            acceptedOperations: ["mutation"]
+          });
+        }
+        const command = getCommand({ params, assertIsValid });
+        const result = await command.execute({ cacheControlConfig: { type: "no-cache" } });
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          return result.value.data;
+        } else {
+          return toGraphQLResponseFromFailure$1(result.error.failure);
+        }
+      } catch (error) {
+        logError$1(error);
+        return {
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        };
+      }
+    };
   }
 }
+function buildServiceDescriptor$7() {
+  return {
+    type: "graphQLMutationBindings",
+    version: "1.0",
+    service: new GraphQLMutationBindingsService()
+  };
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function setHeader(headerName, headerValue, [resource, options = {}], {
-  throwOnExisting = false,
-  errorMessage = `Unexpected ${headerName} header encountered`
-} = {}) {
-  let hasHeaderBeenSet = false;
-  if (resource instanceof Request && !(options == null ? void 0 : options.headers)) {
-    if (throwOnExisting && resource.headers.has(headerName)) {
-      throw new Error(errorMessage);
+class Sanitizer {
+  constructor(obj) {
+    this.obj = obj;
+    this.copy = {};
+    this.currentPath = {
+      key: "",
+      value: obj,
+      parent: null,
+      data: this.copy
+    };
+  }
+  sanitize() {
+    const sanitizer = this;
+    JSON.stringify(this.obj, function(key, value) {
+      if (key === "") {
+        return value;
+      }
+      const parent = this;
+      if (parent !== sanitizer.currentPath.value) {
+        sanitizer.exit(parent);
+      }
+      if (typeof value === "object" && value !== null) {
+        sanitizer.enter(key, value);
+        return value;
+      }
+      sanitizer.currentPath.data[key] = value;
+      return value;
+    });
+    return this.copy;
+  }
+  enter(key, value) {
+    const { currentPath: parentPath } = this;
+    const data = parentPath.data[key] = Array.isArray(value) ? [] : {};
+    this.currentPath = {
+      key,
+      value,
+      parent: parentPath,
+      data
+    };
+  }
+  exit(parent) {
+    while (this.currentPath.value !== parent) {
+      this.currentPath = this.currentPath.parent || this.currentPath;
     }
-    resource.headers.set(headerName, headerValue);
-    hasHeaderBeenSet = true;
   }
-  if ((options == null ? void 0 : options.headers) instanceof Headers) {
-    if (throwOnExisting && options.headers.has(headerName)) {
-      throw new Error(errorMessage);
+}
+function sanitize(obj) {
+  return new Sanitizer(obj).sanitize();
+}
+function isIncompleteConfigError(err) {
+  return err instanceof MissingRequiredPropertyError || err instanceof JsonSchemaViolationError && err.validationErrors.find(
+    (validationError) => validationError instanceof MissingRequiredPropertyError
+  ) !== void 0;
+}
+class CommandWireAdapterConstructor {
+  constructor(callback, sourceContext, options) {
+    this.callback = callback;
+    this.connected = false;
+    this.exposeRefresh = false;
+    if (!(options == null ? void 0 : options.skipEmptyEmit)) {
+      this.emit();
     }
-    options.headers.set(headerName, headerValue);
-  } else {
-    if (throwOnExisting && (options == null ? void 0 : options.headers) && Reflect.has(options.headers, headerName)) {
-      throw new Error(errorMessage);
+  }
+  connect() {
+    this.connected = true;
+    this.invokeAdapter();
+  }
+  disconnect() {
+    this.unsubscribe();
+    this.connected = false;
+  }
+  update(config, _context) {
+    this.unsubscribe();
+    this.config = sanitize(config);
+    this.invokeAdapter();
+  }
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, error: void 0 });
+      } else {
+        const consumerEmittedRefresh = () => {
+          if (!this.refresh) {
+            return Promise.resolve();
+          }
+          return new Promise((resolve, reject) => {
+            if (!this.refresh) {
+              resolve();
+              return;
+            }
+            this.refresh().then((res) => {
+              if (res.isOk()) {
+                resolve();
+              } else {
+                reject(
+                  new Error(
+                    "Internal error in Lightning Data Service adapter occurred: Failed to refresh data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          error: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          if (isSubscribableResult(result)) {
+            consumerEmittedData.error = result.error.failure;
+          } else {
+            consumerEmittedData.error = result.error;
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            deepFreeze(result.value.data);
+            consumerEmittedData.data = result.value.data;
+          } else {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value;
+          }
+        }
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      this.handleExecutionThrow(e);
     }
-    if (!hasHeaderBeenSet) {
-      options.headers = {
-        ...options == null ? void 0 : options.headers,
-        [headerName]: headerValue
-      };
+  }
+  invokeAdapter() {
+    if (!this.connected || this.config === void 0) {
+      return;
+    }
+    if (this.configSchema) {
+      try {
+        assertIsValid(this.config, this.configSchema);
+      } catch (err) {
+        if (isIncompleteConfigError(err)) {
+          return;
+        }
+        throw err;
+      }
+    }
+    const initialConfig = this.config;
+    const command = this.getCommand();
+    try {
+      command.execute().then((result) => {
+        if (!this.connected || this.config !== initialConfig) {
+          return;
+        }
+        this.refresh = void 0;
+        if (result.isOk()) {
+          if (isSubscribableResult(result)) {
+            const value = result.value;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(ok$2(value.data));
+          } else {
+            this.emit(result);
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            const value = result.error;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(result);
+          } else {
+            this.unsubscriber = () => {
+            };
+            this.emit(result);
+          }
+        }
+      });
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(error) {
+    emitError(this.callback, error);
+  }
+  unsubscribe() {
+    if (this.unsubscriber) {
+      this.unsubscriber();
+      delete this.unsubscriber;
     }
   }
-  return [resource, options];
 }
-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 }, fetchParams) {
-  const authorizationValue = `Bearer ${token}`;
-  return setHeader("Authorization", authorizationValue, fetchParams, {
-    throwOnExisting: true,
-    errorMessage: UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE
-  });
+function toGraphQLResponseFromFailure(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
+  }
+  logError$1(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
 }
-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;
+class LWCWireBindingsService {
+  bind(getCommand, configSchema, exposeRefresh = false) {
+    return class extends CommandWireAdapterConstructor {
+      constructor() {
+        super(...arguments);
+        this.configSchema = configSchema;
+        this.exposeRefresh = exposeRefresh;
+      }
+      getCommand() {
+        return getCommand(this.config);
+      }
+    };
+  }
+}
+function buildServiceDescriptor$1() {
+  return {
+    type: "lwcWireBindings",
+    version: "1.0",
+    service: new LWCWireBindingsService()
+  };
+}
+class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, errors: void 0 });
+      } else {
+        const consumerEmittedRefresh = () => {
+          if (!this.refresh) {
+            return Promise.resolve();
+          }
+          return new Promise((resolve, reject) => {
+            if (!this.refresh) {
+              resolve();
+              return;
+            }
+            this.refresh().then((res) => {
+              if (res.isOk()) {
+                resolve();
+              } else {
+                reject(
+                  new Error(
+                    "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          const failure = isSubscribableResult(result) ? result.error.failure : result.error;
+          const resp = toGraphQLResponseFromFailure(failure);
+          consumerEmittedData.data = resp.data;
+          consumerEmittedData.errors = resp.errors;
+        } else {
+          consumerEmittedData.data = result.value.data;
+        }
+        deepFreeze(consumerEmittedData);
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      logError$1(e);
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(e) {
+    logError$1(e);
+    this.callback({
+      data: void 0,
+      errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
     });
+  }
+  update(config, _context) {
+    this.unsubscribe();
+    const resolvedQuery = resolveAst(config.query);
+    if (resolvedQuery) {
+      validateGraphQLOperations(
+        { query: resolvedQuery, operationName: config == null ? void 0 : config.operationName },
+        { acceptedOperations: ["query"] }
+      );
+    }
+    this.config = {
+      ...sanitize(config),
+      query: resolvedQuery
+    };
+    this.invokeAdapter();
+  }
+}
+class LWCGraphQLWireBindingsService {
+  bind(getCommand, configSchema, exposeRefresh = false) {
+    return class extends GraphQLCommandWireAdapterConstructor {
+      constructor() {
+        super(...arguments);
+        this.configSchema = configSchema;
+        this.exposeRefresh = exposeRefresh;
+      }
+      getCommand() {
+        return getCommand(this.config);
+      }
+    };
+  }
+}
+function buildServiceDescriptor$2() {
+  return {
+    type: "lwcGraphQLWireBindings",
+    version: "1.0",
+    service: new LWCGraphQLWireBindingsService()
   };
 }
 
-var SnapshotState;
-(function (SnapshotState) {
-    SnapshotState["Fulfilled"] = "Fulfilled";
-    SnapshotState["Unfulfilled"] = "Unfulfilled";
-    SnapshotState["Error"] = "Error";
-    SnapshotState["Pending"] = "Pending";
-    SnapshotState["Stale"] = "Stale";
-})(SnapshotState || (SnapshotState = {}));
-const { isArray: isArray$1 } = Array;
-
-Promise.resolve();
+function createLockerCompatibleWireConstructor(DelegateCtor) {
+    function Constructor(callback, sourceContext, options) {
+        const delegate = new DelegateCtor(callback, sourceContext, options);
+        this.connect = () => delegate.connect();
+        this.disconnect = () => delegate.disconnect();
+        this.update = (config, context) => delegate.update(config, context);
+    }
+    return Constructor;
+}
+function buildLWCWireBindingsServiceDescriptor() {
+    const base = buildServiceDescriptor$1();
+    const originalBind = base.service.bind.bind(base.service);
+    const bind = (...args) => {
+        const ctor = originalBind(...args);
+        return createLockerCompatibleWireConstructor(ctor);
+    };
+    return {
+        ...base,
+        service: {
+            ...base.service,
+            bind,
+        },
+    };
+}
+function buildLWCGraphQLWireBindingsServiceDescriptor() {
+    const base = buildServiceDescriptor$2();
+    const originalBind = base.service.bind.bind(base.service);
+    const bind = (...args) => {
+        const ctor = originalBind(...args);
+        return createLockerCompatibleWireConstructor(ctor);
+    };
+    return {
+        ...base,
+        service: {
+            ...base.service,
+            bind,
+        },
+    };
+}
 
-var StoreErrorStatus;
-(function (StoreErrorStatus) {
-    StoreErrorStatus[StoreErrorStatus["RESOURCE_NOT_FOUND"] = 404] = "RESOURCE_NOT_FOUND";
-})(StoreErrorStatus || (StoreErrorStatus = {}));
-var StoreRecordType;
-(function (StoreRecordType) {
-    StoreRecordType["Error"] = "error";
-})(StoreRecordType || (StoreRecordType = {}));
-var StoreLinkStateValues$1;
-(function (StoreLinkStateValues) {
-    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
-    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
-    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
-    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
-    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
-    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
-})(StoreLinkStateValues$1 || (StoreLinkStateValues$1 = {}));
-var StoreResolveResultState;
-(function (StoreResolveResultState) {
-    StoreResolveResultState[StoreResolveResultState["Found"] = 0] = "Found";
-    StoreResolveResultState[StoreResolveResultState["Error"] = 1] = "Error";
-    StoreResolveResultState[StoreResolveResultState["Null"] = 2] = "Null";
-    StoreResolveResultState[StoreResolveResultState["NotPresent"] = 3] = "NotPresent";
-    StoreResolveResultState[StoreResolveResultState["Stale"] = 4] = "Stale";
-})(StoreResolveResultState || (StoreResolveResultState = {}));
-var HttpStatusCode;
-(function (HttpStatusCode) {
-    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
-    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
-    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
-    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
-    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
-    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
-    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
-    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
-    HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
-    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
-})(HttpStatusCode || (HttpStatusCode = {}));
-/**
- * A type guard function for determining if an unknown object is a {@link FormData}
- */
-function isFormData(obj) {
-    return (typeof obj === 'object' &&
-        obj !== null &&
-        'namedEntries' in obj &&
-        isArray$1(obj.namedEntries));
-}
-/**
- * A type guard function for determining if an unknown object is a {@link FileReference}
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
  */
-function isFileReference(entryValue) {
-    return (typeof entryValue === 'object' &&
-        entryValue !== null &&
-        'isFileReference' in entryValue &&
-        entryValue.isFileReference === true);
+function e$1(e2) {
+  this.message = e2;
 }
-var GraphNodeType;
-(function (GraphNodeType) {
-    GraphNodeType["Link"] = "Link";
-    GraphNodeType["Node"] = "Node";
-    GraphNodeType["Error"] = "Error";
-    GraphNodeType["Locked"] = "Locked";
-})(GraphNodeType || (GraphNodeType = {}));
-
-var StoreLinkStateValues;
-(function (StoreLinkStateValues) {
-    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
-    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
-    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
-    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
-    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
-    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
-})(StoreLinkStateValues || (StoreLinkStateValues = {}));
-var FragmentReadResultState;
-(function (FragmentReadResultState) {
-    FragmentReadResultState[FragmentReadResultState["Missing"] = 0] = "Missing";
-    FragmentReadResultState[FragmentReadResultState["Success"] = 1] = "Success";
-    FragmentReadResultState[FragmentReadResultState["Error"] = 2] = "Error";
-})(FragmentReadResultState || (FragmentReadResultState = {}));
-({
-    state: FragmentReadResultState.Missing,
-});
-
-var ResourceParamType;
-(function (ResourceParamType) {
-    ResourceParamType[ResourceParamType["UrlParameter"] = 0] = "UrlParameter";
-    ResourceParamType[ResourceParamType["QueryParameter"] = 1] = "QueryParameter";
-    ResourceParamType[ResourceParamType["Body"] = 2] = "Body";
-    ResourceParamType[ResourceParamType["Header"] = 3] = "Header";
-})(ResourceParamType || (ResourceParamType = {}));
-var TypeCheckShapes;
-(function (TypeCheckShapes) {
-    TypeCheckShapes[TypeCheckShapes["String"] = 0] = "String";
-    TypeCheckShapes[TypeCheckShapes["Boolean"] = 1] = "Boolean";
-    TypeCheckShapes[TypeCheckShapes["Number"] = 2] = "Number";
-    TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
-    TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
-})(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.158.7-bafe2646
-
-const { keys: keys$1 } = Object;
-
-// we're going to intentionally bundle this small bit of luvio engine code into
-// this module to keep it runtime dependency-free
-const fetchNetworkAdapter = async (resourceRequest, _resourceRequestContext) => {
-    const { baseUri, basePath, body: requestBody, queryParams, method, headers } = resourceRequest;
-    const qs = generateQueryString(queryParams);
-    const path = `${baseUri}${basePath}${qs}`;
-    let body;
-    // some endpoints use FormData for POST request body, check here
-    // if we have a POST body that is FormData
-    if (method === 'post' && isFormData(requestBody)) {
-        // we will populate a DOM FormData and pass that to fetch
-        const newForm = new FormData();
-        for (const { name, value } of requestBody.namedEntries) {
-            // if this is a string or real DOM File then we can
-            // just add it to FormData
-            if (typeof value === 'string' || value instanceof File) {
-                newForm.append(name, value);
-            }
-            // this network adapter doesn't currently support FileReference's
-            else if (isFileReference(value)) {
-                throw Error(`Luvio fetchNetworkAdapter does not support FileReference's`);
-            }
-            // else we have a Luvio File that isn't a real DOM file,
-            // so we need to turn it into a DOM file
-            else {
-                const buffer = await value.arrayBuffer();
-                newForm.append(name, new File([new Uint8Array(buffer)], value.name, {
-                    type: value.type,
-                }));
-            }
-        }
-        body = newForm;
-    }
-    else if (requestBody === null) {
-        body = null;
-    }
-    else {
-        body = JSON.stringify(requestBody);
-        headers['Content-Type'] = 'application/json';
-    }
-    const response = await fetch(path, {
-        method: method.toUpperCase(),
-        headers: generateHeaders(headers),
-        body,
-    });
-    const { status, ok, statusText } = response;
-    // coerce headers
-    const responseHeaders = {};
-    response.headers.forEach((value, key) => {
-        responseHeaders[key] = value;
-    });
-    // parse body
-    let responseBody = null;
-    if (status !== 204) {
-        const contentType = responseHeaders['content-type'];
-        responseBody =
-            contentType && contentType.startsWith('application/json')
-                ? await response.json()
-                : await response.text();
-    }
-    return {
-        body: responseBody,
-        status,
-        statusText,
-        ok,
-        headers: responseHeaders,
-    };
+e$1.prototype = new Error(), e$1.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$1("'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 generateQueryString(params) {
-    const queryStrings = [];
-    for (const key of keys$1(params)) {
-        queryStrings.push(`${key}=${params[key]}`);
-    }
-    if (queryStrings.length > 0) {
-        return `?${queryStrings.join('&')}`;
-    }
-    return '';
+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 generateHeaders(headers) {
-    const fetchHeaders = new Headers();
-    for (const key of keys$1(headers)) {
-        fetchHeaders.set(key, headers[key]);
-    }
-    return fetchHeaders;
+function n$1(e2) {
+  this.message = e2;
 }
-
-const SALESFORCE_API_BASE_URI_FLAG = 'api.salesforce.com';
-const SFAPController = 'SalesforceApiPlatformController';
-const SFAPJwtMethod = 'getSFAPLightningJwtService';
-/**
- * We expect jwt info and baseUri to be present in the response.
- *
- * @param body
- */
-function validateResponse(body) {
-    if (!body || !body.jwt || !body.baseUri) {
-        // wrapped the invocation in env conditional
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error(`Expected jwt info and baseUri to be present but instead got: ${JSON.stringify(body)}`);
-    }
+function o(e2, r2) {
+  if ("string" != typeof e2) throw new n$1("Invalid token specified");
+  var o2 = true === (r2 = r2 || {}).header ? 0 : 1;
+  try {
+    return JSON.parse(t(e2.split(".")[o2]));
+  } catch (e3) {
+    throw new n$1("Invalid token specified: " + e3.message);
+  }
 }
-/**
- * Resolves Jwt token for SFAP by calling Aura action
- * {@link JwtResolver} for platform SFAP
- */
-const platformSfapJwtResolver = {
-    getJwt() {
-        return new Promise((resolve, reject) => {
-            dispatchAuraAction(`${SFAPController}.${SFAPJwtMethod}`, {}, defaultActionConfig)
-                .then((response) => {
-                const body = response.body;
-                if (process.env.NODE_ENV !== 'production') {
-                    validateResponse(body);
-                }
-                resolve({
-                    jwt: body.jwt,
-                    extraInfo: {
-                        baseUri: body.baseUri,
-                    },
-                });
-            })
-                .catch((error) => {
-                if (error instanceof Error) {
-                    reject(error.message);
-                    return;
-                }
-                // AuraFetchResponse errors
-                const { status } = error;
-                if (status !== HttpStatusCode$2.ServerError) {
-                    // ConnectInJavaError
-                    reject(error.body.message);
-                    return;
-                }
-                reject(error.body.error);
-            });
-        });
-    },
+n$1.prototype = new Error(), n$1.prototype.name = "InvalidTokenError";
+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: () => {
+  }
 };
-const jwtManager = new JwtManager(new JwtRepository(), platformSfapJwtResolver);
-const authenticateRequest = (resourceRequest, jwt) => {
-    const { token } = jwt;
-    const { headers } = resourceRequest;
-    // Only supporting Bearer <auth-scheme>
-    const authenticatedHeaders = {
-        ...headers,
-        Authorization: `Bearer ${token}`,
-    };
-    return {
-        ...resourceRequest,
-        headers: authenticatedHeaders,
+if (process.env.NODE_ENV !== "production") {
+  defaultLogger = loggerService();
+}
+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);
     };
-};
-/**
- * This hook is used to modify the resource request before it is sent to the server.
- * SFAP uses extraInfo assocaiated JwtToken to update the baseUri for the resource request.
- *
- * @param resourceRequest
- * @param jwtToken
- * @returns resourceRequest with updated baseUri
+  }
+  /**
+   * 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
  */
-const modifySfapResourceRequest = function (resourceRequest, jwtToken) {
-    const { baseUri } = jwtToken.extraInfo;
-    return {
-        ...resourceRequest,
-        baseUri,
-    };
-};
-const sfapNetworkAdapter = async (resourceRequest, resourceRequestContext) => {
-    let jwtToken;
-    try {
-        jwtToken = await jwtManager.getJwt();
+function setHeader(headerName, headerValue, [resource, options = {}], {
+  throwOnExisting = false,
+  errorMessage = `Unexpected ${headerName} header encountered`
+} = {}) {
+  let hasHeaderBeenSet = false;
+  if (resource instanceof Request && !(options == null ? void 0 : options.headers)) {
+    if (throwOnExisting && resource.headers.has(headerName)) {
+      throw new Error(errorMessage);
     }
-    catch (error) {
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`There was an error while fetching Jwt token: ${JSON.stringify(error)}`);
-        }
-        return Promise.reject(new LdsNetworkAdapterErrorResponse('Unable to fetch the jwt required to make this request', error));
+    resource.headers.set(headerName, headerValue);
+    hasHeaderBeenSet = true;
+  }
+  if ((options == null ? void 0 : options.headers) instanceof Headers) {
+    if (throwOnExisting && options.headers.has(headerName)) {
+      throw new Error(errorMessage);
     }
-    let authenticatedRequest = authenticateRequest(resourceRequest, jwtToken);
-    authenticatedRequest = modifySfapResourceRequest(authenticatedRequest, jwtToken);
-    return fetchNetworkAdapter(authenticatedRequest);
-};
-class LdsNetworkAdapterErrorResponse extends Error {
-    constructor(message, _error) {
-        super(message);
-        this._error = _error;
-        this.errorType = 'networkAdapterError';
-        this.name = this.constructor.name;
+    options.headers.set(headerName, headerValue);
+  } else {
+    if (throwOnExisting && (options == null ? void 0 : options.headers) && Reflect.has(options.headers, headerName)) {
+      throw new Error(errorMessage);
+    }
+    if (!hasHeaderBeenSet) {
+      options.headers = {
+        ...options == null ? void 0 : options.headers,
+        [headerName]: headerValue
+      };
     }
+  }
+  return [resource, options];
+}
+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 }, fetchParams) {
+  const authorizationValue = `Bearer ${token}`;
+  return setHeader("Authorization", authorizationValue, fetchParams, {
+    throwOnExisting: true,
+    errorMessage: UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE
+  });
+}
+function buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier = (_e, fetchArgs) => fetchArgs) {
+  return (args) => {
+    return resolvedPromiseLike$2(jwtManager.getJwt()).then((token) => {
+      const fetchArgsWithRequestHeaderAuthorization = setHeaderAuthorization(token, args);
+      return token.extraInfo ? jwtRequestModifier(token.extraInfo, fetchArgsWithRequestHeaderAuthorization) : fetchArgsWithRequestHeaderAuthorization;
+    });
+  };
 }
-const composedNetworkAdapter$1 = {
-    shouldHandleRequest(resourceRequest) {
-        return resourceRequest.baseUri === SALESFORCE_API_BASE_URI_FLAG;
-    },
-    adapter: sfapNetworkAdapter,
-};
 
-function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";"undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function n(e){this.message=e;}n.prototype=new Error,n.prototype.name="InvalidTokenError";
+var SnapshotState;
+(function (SnapshotState) {
+    SnapshotState["Fulfilled"] = "Fulfilled";
+    SnapshotState["Unfulfilled"] = "Unfulfilled";
+    SnapshotState["Error"] = "Error";
+    SnapshotState["Pending"] = "Pending";
+    SnapshotState["Stale"] = "Stale";
+})(SnapshotState || (SnapshotState = {}));
+const { isArray: isArray$1 } = Array;
 
-function buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger) {
-    return async (response) => {
-        if (response.status === 401) {
-            try {
-                const coercedResponse = (await coerceResponseToFetchResponse(response.clone()));
-                if (coercedResponse.body.errorCode === 'INVALID_SESSION_ID') {
-                    logger.warn(`Received ${response.status} status code from LEX runtime service`);
-                    // Fire the event asynchronously, similar to the legacy setTimeout pattern
-                    window.setTimeout(() => {
-                        dispatchGlobalEvent('aura:invalidSession');
-                    }, 0);
-                }
+Promise.resolve();
+
+var StoreErrorStatus;
+(function (StoreErrorStatus) {
+    StoreErrorStatus[StoreErrorStatus["RESOURCE_NOT_FOUND"] = 404] = "RESOURCE_NOT_FOUND";
+})(StoreErrorStatus || (StoreErrorStatus = {}));
+var StoreRecordType;
+(function (StoreRecordType) {
+    StoreRecordType["Error"] = "error";
+})(StoreRecordType || (StoreRecordType = {}));
+var StoreLinkStateValues$1;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues$1 || (StoreLinkStateValues$1 = {}));
+var StoreResolveResultState;
+(function (StoreResolveResultState) {
+    StoreResolveResultState[StoreResolveResultState["Found"] = 0] = "Found";
+    StoreResolveResultState[StoreResolveResultState["Error"] = 1] = "Error";
+    StoreResolveResultState[StoreResolveResultState["Null"] = 2] = "Null";
+    StoreResolveResultState[StoreResolveResultState["NotPresent"] = 3] = "NotPresent";
+    StoreResolveResultState[StoreResolveResultState["Stale"] = 4] = "Stale";
+})(StoreResolveResultState || (StoreResolveResultState = {}));
+var HttpStatusCode;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+})(HttpStatusCode || (HttpStatusCode = {}));
+/**
+ * A type guard function for determining if an unknown object is a {@link FormData}
+ */
+function isFormData(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'namedEntries' in obj &&
+        isArray$1(obj.namedEntries));
+}
+/**
+ * A type guard function for determining if an unknown object is a {@link FileReference}
+ */
+function isFileReference(entryValue) {
+    return (typeof entryValue === 'object' &&
+        entryValue !== null &&
+        'isFileReference' in entryValue &&
+        entryValue.isFileReference === true);
+}
+var GraphNodeType;
+(function (GraphNodeType) {
+    GraphNodeType["Link"] = "Link";
+    GraphNodeType["Node"] = "Node";
+    GraphNodeType["Error"] = "Error";
+    GraphNodeType["Locked"] = "Locked";
+})(GraphNodeType || (GraphNodeType = {}));
+
+var StoreLinkStateValues;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues || (StoreLinkStateValues = {}));
+var FragmentReadResultState;
+(function (FragmentReadResultState) {
+    FragmentReadResultState[FragmentReadResultState["Missing"] = 0] = "Missing";
+    FragmentReadResultState[FragmentReadResultState["Success"] = 1] = "Success";
+    FragmentReadResultState[FragmentReadResultState["Error"] = 2] = "Error";
+})(FragmentReadResultState || (FragmentReadResultState = {}));
+({
+    state: FragmentReadResultState.Missing,
+});
+
+var ResourceParamType;
+(function (ResourceParamType) {
+    ResourceParamType[ResourceParamType["UrlParameter"] = 0] = "UrlParameter";
+    ResourceParamType[ResourceParamType["QueryParameter"] = 1] = "QueryParameter";
+    ResourceParamType[ResourceParamType["Body"] = 2] = "Body";
+    ResourceParamType[ResourceParamType["Header"] = 3] = "Header";
+})(ResourceParamType || (ResourceParamType = {}));
+var TypeCheckShapes;
+(function (TypeCheckShapes) {
+    TypeCheckShapes[TypeCheckShapes["String"] = 0] = "String";
+    TypeCheckShapes[TypeCheckShapes["Boolean"] = 1] = "Boolean";
+    TypeCheckShapes[TypeCheckShapes["Number"] = 2] = "Number";
+    TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
+    TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
+})(TypeCheckShapes || (TypeCheckShapes = {}));
+// engine version: 0.158.7-bafe2646
+
+const { keys: keys$1 } = Object;
+
+// we're going to intentionally bundle this small bit of luvio engine code into
+// this module to keep it runtime dependency-free
+const fetchNetworkAdapter = async (resourceRequest, _resourceRequestContext) => {
+    const { baseUri, basePath, body: requestBody, queryParams, method, headers } = resourceRequest;
+    const qs = generateQueryString(queryParams);
+    const path = `${baseUri}${basePath}${qs}`;
+    let body;
+    // some endpoints use FormData for POST request body, check here
+    // if we have a POST body that is FormData
+    if (method === 'post' && isFormData(requestBody)) {
+        // we will populate a DOM FormData and pass that to fetch
+        const newForm = new FormData();
+        for (const { name, value } of requestBody.namedEntries) {
+            // if this is a string or real DOM File then we can
+            // just add it to FormData
+            if (typeof value === 'string' || value instanceof File) {
+                newForm.append(name, value);
             }
-            catch (error) {
-                logger.warn(`Error parsing response from LEX runtime service: ${error}`);
+            // this network adapter doesn't currently support FileReference's
+            else if (isFileReference(value)) {
+                throw Error(`Luvio fetchNetworkAdapter does not support FileReference's`);
             }
-        }
-        return response;
-    };
-}
-function buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor() {
-    return async (response) => {
-        if (response.status === 401) {
-            if (response.body.errorCode === 'INVALID_SESSION_ID') {
-                window.setTimeout(() => {
-                    dispatchGlobalEvent('aura:invalidSession');
-                }, 0);
+            // else we have a Luvio File that isn't a real DOM file,
+            // so we need to turn it into a DOM file
+            else {
+                const buffer = await value.arrayBuffer();
+                newForm.append(name, new File([new Uint8Array(buffer)], value.name, {
+                    type: value.type,
+                }));
             }
         }
-        return response;
+        body = newForm;
+    }
+    else if (requestBody === null) {
+        body = null;
+    }
+    else {
+        body = JSON.stringify(requestBody);
+        headers['Content-Type'] = 'application/json';
+    }
+    const response = await fetch(path, {
+        method: method.toUpperCase(),
+        headers: generateHeaders(headers),
+        body,
+    });
+    const { status, ok, statusText } = response;
+    // coerce headers
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+    });
+    // parse body
+    let responseBody = null;
+    if (status !== 204) {
+        const contentType = responseHeaders['content-type'];
+        responseBody =
+            contentType && contentType.startsWith('application/json')
+                ? await response.json()
+                : await response.text();
+    }
+    return {
+        body: responseBody,
+        status,
+        statusText,
+        ok,
+        headers: responseHeaders,
     };
-}
-
-/**
- * Extracts the ErrorId from a server error response message.
- * Looks for pattern: "ErrorId if you contact support: 1033627214-37969 (-1272663771)"
- * Returns the numeric value in parentheses.
- *
- * @param responseBody The response body text to parse.
- * @returns The extracted error ID, or null if not found.
- */
-function extractErrorIdFromResponse(responseBody) {
-    try {
-        const parsed = JSON.parse(responseBody);
-        if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].message) {
-            const message = parsed[0].message;
-            // Look for pattern: "ErrorId if you contact support: XXXXXX-XXXXX (YYYYY)"
-            const match = message.match(/ErrorId[^:]*:\s*[\d-]+\s*\((-?\d+)\)/);
-            if (match && match[1]) {
-                return parseInt(match[1], 10);
-            }
-        }
+};
+function generateQueryString(params) {
+    const queryStrings = [];
+    for (const key of keys$1(params)) {
+        queryStrings.push(`${key}=${params[key]}`);
     }
-    catch (e) {
-        // If parsing fails, return null to use fallback
+    if (queryStrings.length > 0) {
+        return `?${queryStrings.join('&')}`;
     }
-    return null;
+    return '';
 }
-/**
- * Generates a unique error ID for tracking specific error occurrences.
- * Used as fallback when server doesn't provide an ErrorId.
- *
- * @param idInput The input value to hash.
- * @returns A unique error ID in Salesforce-compatible numeric format.
- */
-function generateErrorId(idInput) {
-    let hash = 0;
-    if (!idInput || idInput.length === 0) {
-        return hash;
-    }
-    let i, chr;
-    for (i = 0; i < idInput.length; i++) {
-        chr = idInput.charCodeAt(i);
-        hash = (hash << 5) - hash + chr;
-        hash |= 0; // Convert to 32bit integer
+function generateHeaders(headers) {
+    const fetchHeaders = new Headers();
+    for (const key of keys$1(headers)) {
+        fetchHeaders.set(key, headers[key]);
     }
-    return hash;
+    return fetchHeaders;
 }
+
+const SALESFORCE_API_BASE_URI_FLAG = 'api.salesforce.com';
+const X_REQUEST_ID_HEADER = 'x-request-id';
+const SFAPController = 'SalesforceApiPlatformController';
+const SFAPJwtMethod = 'getSFAPLightningJwtService';
 /**
- * Gets error ID from response body or generates a fallback.
- * Tries to extract server-provided ErrorId first, falls back to generated hash.
+ * We expect jwt info and baseUri to be present in the response.
  *
- * @param responseBody The response body to parse.
- * @param status The HTTP status code (for fallback).
- * @param statusText The HTTP status text (for fallback, optional).
- * @returns A numeric error ID.
+ * @param body
  */
-function getOrGenerateErrorId(responseBody, status, statusText) {
-    const extractedId = extractErrorIdFromResponse(responseBody);
-    if (extractedId !== null) {
-        return extractedId;
+function validateResponse(body) {
+    if (!body || !body.jwt || !body.baseUri) {
+        // wrapped the invocation in env conditional
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`Expected jwt info and baseUri to be present but instead got: ${JSON.stringify(body)}`);
     }
-    // Fallback to generated error ID using status and timestamp
-    // statusText is optional and may not always be present
-    const context = [status, statusText || '', Date.now()].join('|');
-    return generateErrorId(context);
-}
-function buildLexRuntime5xxStatusResponseInterceptor(logger) {
-    return async (response) => {
-        if (response.status >= 500 && response.status < 600) {
-            const internalLogMessage = `LEX runtime 5xx: ${response.status} ${response.statusText || ''}`.trim();
-            logger.warn(internalLogMessage);
-            const userMessage = 'A server error occurred. Please try again later.';
-            // Try to extract ErrorId from response body, fallback to generated ID
-            let errorId;
-            try {
-                const responseText = await response.clone().text();
-                errorId = getOrGenerateErrorId(responseText, response.status, response.statusText);
-            }
-            catch (e) {
-                // If reading response fails, use fallback
-                const context = [response.status, response.statusText, Date.now()].join('|');
-                errorId = generateErrorId(context);
-            }
-            // Create an error object similar to Aura's current shape for system errors
-            const error = {
-                message: userMessage,
-                severity: 'ALERT',
-                name: 'LEXRuntimeError',
-                stack: null,
-                handled: false,
-                reported: false,
-                id: errorId,
-            };
-            const evtArgs = {
-                message: error.message,
-                error: null,
-                auraError: error,
-            };
-            // Fire the event asynchronously, similar to the legacy setTimeout pattern
-            window.setTimeout(() => {
-                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
-            }, 0);
-            // Throw a simple error to terminate the request completely
-            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
-            // The systemError event above will handle showing the gack dialog
-            throw new Error(error.message);
-        }
-        return response;
-    };
-}
-function buildLexRuntimeLuvio5xxStatusResponseInterceptor() {
-    return async (response) => {
-        if (response.status >= 500 && response.status < 600) {
-            const userMessage = 'A server error occurred. Please try again later.';
-            // Try to extract ErrorId from response body, fallback to generated ID
-            let errorId;
-            try {
-                const responseBody = response.body ? JSON.stringify(response.body) : '';
-                errorId = getOrGenerateErrorId(responseBody, response.status, response.statusText);
-            }
-            catch (e) {
-                // If reading response fails, use fallback
-                const context = [response.status, response.statusText, Date.now()].join('|');
-                errorId = generateErrorId(context);
-            }
-            // Create an error object similar to Aura's current shape for system errors
-            const error = {
-                message: userMessage,
-                severity: 'ALERT',
-                name: 'LEXRuntimeError',
-                stack: null,
-                handled: false,
-                reported: false,
-                id: errorId,
-            };
-            const evtArgs = {
-                message: error.message,
-                error: null,
-                auraError: error,
-            };
-            // Fire the event asynchronously, similar to the legacy setTimeout pattern
-            window.setTimeout(() => {
-                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
-            }, 0);
-            // Throw a simple error to terminate the request completely
-            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
-            // The systemError event above will handle showing the gack dialog
-            throw new Error(error.message);
-        }
-        return response;
-    };
 }
-
-function buildPageScopedCacheRequestInterceptor() {
-    return async (fetchArgs) => {
-        const pageScopedCacheHeaders = {};
-        // Allow the instrumentation util to set up the header value on our "dummy" header object
-        pageScopedCache.addHeader(pageScopedCacheHeaders);
-        let returnedFetchArgs = fetchArgs;
-        // If it set a value, add it to our fetchParams
-        Object.entries(pageScopedCacheHeaders).forEach(([key, value]) => {
-            returnedFetchArgs = setHeader(key, value, returnedFetchArgs);
+/**
+ * Resolves Jwt token for SFAP by calling Aura action
+ * {@link JwtResolver} for platform SFAP
+ */
+const platformSfapJwtResolver = {
+    getJwt() {
+        return new Promise((resolve, reject) => {
+            dispatchAuraAction(`${SFAPController}.${SFAPJwtMethod}`, {}, defaultActionConfig)
+                .then((response) => {
+                const body = response.body;
+                if (process.env.NODE_ENV !== 'production') {
+                    validateResponse(body);
+                }
+                resolve({
+                    jwt: body.jwt,
+                    extraInfo: {
+                        baseUri: body.baseUri,
+                    },
+                });
+            })
+                .catch((error) => {
+                if (error instanceof Error) {
+                    reject(error.message);
+                    return;
+                }
+                // AuraFetchResponse errors
+                const { status } = error;
+                if (status !== HttpStatusCode$2.ServerError) {
+                    // ConnectInJavaError
+                    reject(error.body.message);
+                    return;
+                }
+                reject(error.body.error);
+            });
         });
-        return resolvedPromiseLike$3(returnedFetchArgs);
+    },
+};
+const jwtManager = new JwtManager(new JwtRepository(), platformSfapJwtResolver);
+const authenticateRequest = (resourceRequest, jwt) => {
+    const { token } = jwt;
+    const { headers } = resourceRequest;
+    // Only supporting Bearer <auth-scheme>
+    const authenticatedHeaders = {
+        ...headers,
+        Authorization: `Bearer ${token}`,
+    };
+    return {
+        ...resourceRequest,
+        headers: authenticatedHeaders,
+    };
+};
+/**
+ * This hook is used to modify the resource request before it is sent to the server.
+ * SFAP uses extraInfo assocaiated JwtToken to update the baseUri for the resource request.
+ *
+ * @param resourceRequest
+ * @param jwtToken
+ * @returns resourceRequest with updated baseUri
+ */
+const modifySfapResourceRequest = function (resourceRequest, jwtToken) {
+    const { baseUri } = jwtToken.extraInfo;
+    return {
+        ...resourceRequest,
+        baseUri,
     };
+};
+// used for instrumentation and tracking
+let sfapRequestCount = 0;
+const sfapNetworkAdapter = async (resourceRequest, resourceRequestContext) => {
+    let jwtToken;
+    try {
+        jwtToken = await jwtManager.getJwt();
+    }
+    catch (error) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error(`There was an error while fetching Jwt token: ${JSON.stringify(error)}`);
+        }
+        return Promise.reject(new LdsNetworkAdapterErrorResponse('Unable to fetch the jwt required to make this request', error));
+    }
+    let authenticatedRequest = authenticateRequest(resourceRequest, jwtToken);
+    authenticatedRequest = modifySfapResourceRequest(authenticatedRequest, jwtToken);
+    // --- instrumentation block --- start
+    const uniqueRequestTaskIdentifier = 'sfap-' + sfapRequestCount++;
+    const uniqueRequestGuid = generateRequestId();
+    // request id header allows logging the request id and searching for the request logs
+    authenticatedRequest.headers[X_REQUEST_ID_HEADER] = uniqueRequestGuid;
+    let fetchComplete = false;
+    ThirdPartyTracker.registerHandler(uniqueRequestTaskIdentifier, 'sfap-request', () => fetchComplete);
+    markStart('transport', 'request', {
+        auraXHRId: uniqueRequestTaskIdentifier,
+        requestLength: -1,
+        background: false,
+        actionDefs: ['sfap'],
+        requestId: uniqueRequestGuid,
+    });
+    // --- instrumentation block --- end
+    const fetchNetworkAdapterPromise = fetchNetworkAdapter(authenticatedRequest);
+    // --- instrumentation block --- start
+    fetchNetworkAdapterPromise.finally(function requestCompleteTracker() {
+        ThirdPartyTracker.markLoaded(uniqueRequestTaskIdentifier);
+        fetchComplete = true;
+        markEnd('transport', 'request', {
+            auraXHRId: uniqueRequestTaskIdentifier,
+        });
+    });
+    // --- instrumentation block --- end
+    return fetchNetworkAdapterPromise;
+};
+class LdsNetworkAdapterErrorResponse extends Error {
+    constructor(message, _error) {
+        super(message);
+        this._error = _error;
+        this.errorType = 'networkAdapterError';
+        this.name = this.constructor.name;
+    }
+}
+const composedNetworkAdapter$1 = {
+    shouldHandleRequest(resourceRequest) {
+        return resourceRequest.baseUri === SALESFORCE_API_BASE_URI_FLAG;
+    },
+    adapter: sfapNetworkAdapter,
+};
+function generateRequestId() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        // as nov. 2025 caniuse says this has 93.5% support (all modern browsers)
+        return crypto.randomUUID();
+    }
+    else {
+        // fallback to Math.random() if crypto.randomUUID is not available (unlikely)
+        return (Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15));
+    }
 }
 
+function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";"undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function n(e){this.message=e;}n.prototype=new Error,n.prototype.name="InvalidTokenError";
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -4001,7 +4707,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.401.0-c620f9ffed
+// version: 1.403.0-5476a05446
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -4343,506 +5049,858 @@ class Instrumentation {
         this.refreshAdapterEvents[adapterName] += 1;
         this.lastRefreshApiCall = null;
     }
-    /**
-     * Increments call stat for incoming refresh api call, and sets the name
-     * to be used in {@link aggregateRefreshCalls}
-     * @param from The name of the refresh function called.
-     */
-    handleRefreshApiCall(apiName) {
-        this.refreshApiCallEventStats[apiName] += 1;
-        // set function call to be used with aggregateRefreshCalls
-        this.lastRefreshApiCall = apiName;
+    /**
+     * Increments call stat for incoming refresh api call, and sets the name
+     * to be used in {@link aggregateRefreshCalls}
+     * @param from The name of the refresh function called.
+     */
+    handleRefreshApiCall(apiName) {
+        this.refreshApiCallEventStats[apiName] += 1;
+        // set function call to be used with aggregateRefreshCalls
+        this.lastRefreshApiCall = apiName;
+    }
+    /**
+     * W-7302241
+     * Logs refresh call summary stats as a LightningInteraction.
+     */
+    logRefreshStats() {
+        if (keys(this.refreshAdapterEvents).length > 0) {
+            interaction(REFRESH_PAYLOAD_TARGET, REFRESH_PAYLOAD_SCOPE, this.refreshAdapterEvents, REFRESH_EVENTSOURCE, REFRESH_EVENTTYPE, this.refreshApiCallEventStats);
+            this.resetRefreshStats();
+        }
+    }
+    /**
+     * Resets the stat trackers for refresh call events.
+     */
+    resetRefreshStats() {
+        this.refreshAdapterEvents = {};
+        this.refreshApiCallEventStats = {
+            [REFRESH_APEX_KEY]: 0,
+            [REFRESH_UIAPI_KEY]: 0,
+            [SUPPORTED_KEY]: 0,
+            [UNSUPPORTED_KEY]: 0,
+        };
+        this.lastRefreshApiCall = null;
+    }
+    /**
+     * W-7801618
+     * Counter for occurrences where the incoming record to be merged has a different apiName.
+     * Dynamically generated metric, stored in an {@link RecordApiNameChangeCounters} object.
+     *
+     * @param context The transaction context.
+     *
+     * Note: Short-lived metric candidate, remove at the end of 230
+     */
+    incrementRecordApiNameChangeCount(_incomingApiName, existingApiName) {
+        let apiNameChangeCounter = this.recordApiNameChangeCounters[existingApiName];
+        if (apiNameChangeCounter === undefined) {
+            apiNameChangeCounter = counter(createMetricsKey(NAMESPACE, RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME, existingApiName));
+            this.recordApiNameChangeCounters[existingApiName] = apiNameChangeCounter;
+        }
+        apiNameChangeCounter.increment(1);
+    }
+    /**
+     * W-8620679
+     * Increment the counter for an UnfulfilledSnapshotError coming from luvio
+     *
+     * @param context The transaction context.
+     */
+    incrementAdapterRequestErrorCount(context) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        const adapterName = normalizeAdapterName(context.adapterName);
+        let adapterRequestErrorCounter = this.adapterUnfulfilledErrorCounters[adapterName];
+        if (adapterRequestErrorCounter === undefined) {
+            adapterRequestErrorCounter = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_ERROR_COUNT_METRIC_NAME, adapterName));
+            this.adapterUnfulfilledErrorCounters[adapterName] = adapterRequestErrorCounter;
+        }
+        adapterRequestErrorCounter.increment(1);
+        totalAdapterErrorMetric.increment(1);
+    }
+}
+function createMetricsKey(owner, name, unit) {
+    let metricName = name;
+    if (unit) {
+        metricName = metricName + '.' + unit;
+    }
+    return {
+        get() {
+            return { owner: owner, name: metricName };
+        },
+    };
+}
+/**
+ * Returns whether adapter is an Apex one or not.
+ * @param adapterName The name of the adapter.
+ */
+function isApexAdapter(adapterName) {
+    return adapterName.indexOf(APEX_ADAPTER_NAME) > -1;
+}
+/**
+ * Normalizes getApex adapter names to `Apex.getApex`. Non-Apex adapters will be prefixed with
+ * API family, if supplied. Example: `UiApi.getRecord`.
+ *
+ * Note: If you are adding additional logging that can come from getApex adapter contexts that provide
+ * the full getApex adapter name (i.e. getApex_[namespace]_[class]_[function]_[continuation]),
+ * ensure to call this method to normalize all logging to 'getApex'. This
+ * is because Argus has a 50k key cardinality limit. More context: W-8379680.
+ *
+ * @param adapterName The name of the adapter.
+ * @param apiFamily The API family of the adapter.
+ */
+function normalizeAdapterName(adapterName, apiFamily) {
+    if (isApexAdapter(adapterName)) {
+        return NORMALIZED_APEX_ADAPTER_NAME;
+    }
+    return apiFamily ? `${apiFamily}.${adapterName}` : adapterName;
+}
+const timerMetricTracker = create(null);
+/**
+ * Calls instrumentation/service telemetry timer
+ * @param name Name of the metric
+ * @param duration number to update backing percentile histogram, negative numbers ignored
+ */
+function updateTimerMetric(name, duration) {
+    let metric = timerMetricTracker[name];
+    if (metric === undefined) {
+        metric = timer(createMetricsKey(NAMESPACE, name));
+        timerMetricTracker[name] = metric;
+    }
+    timerMetricAddDuration(metric, duration);
+}
+function timerMetricAddDuration(timer, duration) {
+    // Guard against negative values since it causes error to be thrown by MetricsService
+    if (duration >= 0) {
+        timer.addDuration(duration);
+    }
+}
+/**
+ * W-10315098
+ * Increments the counter associated with the request response. Counts are bucketed by status.
+ */
+const requestResponseMetricTracker = create(null);
+function incrementRequestResponseCount(cb) {
+    const status = cb().status;
+    let metric = requestResponseMetricTracker[status];
+    if (metric === undefined) {
+        metric = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, NETWORK_ADAPTER_RESPONSE_METRIC_NAME, `${status.valueOf()}`));
+        requestResponseMetricTracker[status] = metric;
+    }
+    metric.increment();
+}
+function logObjectInfoChanged() {
+    logObjectInfoChanged$1();
+}
+/**
+ * Create a new instrumentation cache stats and return it.
+ *
+ * @param name The cache logger name.
+ */
+function registerLdsCacheStats(name) {
+    return registerCacheStats(`${NAMESPACE}:${name}`);
+}
+/**
+ * Add or overwrite hooks that require aura implementations
+ */
+function setAuraInstrumentationHooks() {
+    instrument({
+        recordConflictsResolved: (serverRequestCount) => {
+            // Ignore 0 values which can originate from ADS bridge
+            if (serverRequestCount > 0) {
+                updatePercentileHistogramMetric('record-conflicts-resolved', serverRequestCount);
+            }
+        },
+        nullDisplayValueConflict: ({ fieldType, areValuesEqual }) => {
+            const metricName = `merge-null-dv-count.${fieldType}`;
+            if (fieldType === 'scalar') {
+                incrementCounterMetric(`${metricName}.${areValuesEqual}`);
+            }
+            else {
+                incrementCounterMetric(metricName);
+            }
+        },
+        getRecordNotifyChangeAllowed: incrementGetRecordNotifyChangeAllowCount,
+        getRecordNotifyChangeDropped: incrementGetRecordNotifyChangeDropCount,
+        notifyRecordUpdateAvailableAllowed: incrementNotifyRecordUpdateAvailableAllowCount,
+        notifyRecordUpdateAvailableDropped: incrementNotifyRecordUpdateAvailableDropCount,
+        recordApiNameChanged: instrumentation.incrementRecordApiNameChangeCount.bind(instrumentation),
+        weakEtagZero: instrumentation.aggregateWeakETagEvents.bind(instrumentation),
+        getRecordNotifyChangeNetworkResult: instrumentation.notifyChangeNetwork.bind(instrumentation),
+    });
+    withRegistration('@salesforce/lds-adapters-uiapi', (reg) => setLdsAdaptersUiapiInstrumentation(reg));
+    instrument$1({
+        logCrud: logCRUDLightningInteraction,
+        networkResponse: incrementRequestResponseCount,
+    });
+    instrument$2({
+        error: logError$2,
+    });
+    instrument$3({
+        refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
+        instrumentAdapter: instrumentation.instrumentAdapter.bind(instrumentation),
+    });
+    instrument$4({
+        timerMetricAddDuration: updateTimerMetric,
+    });
+    // Our getRecord through aggregate-ui CRUD logging has moved
+    // to lds-network-adapter. We still need to respect the
+    // orgs environment setting
+    if (forceRecordTransactionsDisabled$1 === false) {
+        ldsNetworkAdapterInstrument({
+            getRecordAggregateResolve: (cb) => {
+                const { recordId, apiName } = cb();
+                logCRUDLightningInteraction('read', {
+                    recordId,
+                    recordType: apiName,
+                    state: 'SUCCESS',
+                });
+            },
+            getRecordAggregateReject: (cb) => {
+                const recordId = cb();
+                logCRUDLightningInteraction('read', {
+                    recordId,
+                    state: 'ERROR',
+                });
+            },
+        });
+    }
+    withRegistration('@salesforce/lds-network-adapter', (reg) => setLdsNetworkAdapterInstrumentation(reg));
+}
+let stateManagerInstrumentationHooksInitialized = false;
+function setStateManagerInstrumentationHooks() {
+    if (stateManagerInstrumentationHooksInitialized) {
+        return;
     }
-    /**
-     * W-7302241
-     * Logs refresh call summary stats as a LightningInteraction.
-     */
-    logRefreshStats() {
-        if (keys(this.refreshAdapterEvents).length > 0) {
-            interaction(REFRESH_PAYLOAD_TARGET, REFRESH_PAYLOAD_SCOPE, this.refreshAdapterEvents, REFRESH_EVENTSOURCE, REFRESH_EVENTTYPE, this.refreshApiCallEventStats);
-            this.resetRefreshStats();
-        }
+    instrument$5({
+        stateCreated: incrementStateCreatedCount,
+    });
+    stateManagerInstrumentationHooksInitialized = true;
+}
+/**
+ * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
+ *
+ * @param luvio The Luvio instance to instrument.
+ * @param store The InMemoryStore to instrument.
+ */
+function setupInstrumentation(luvio, store) {
+    setupInstrumentation$1(luvio, store);
+    setAuraInstrumentationHooks();
+    setStateManagerInstrumentationHooks();
+}
+/**
+ * Note: locator.scope is set to 'force_record' in order for the instrumentation gate to work, which will
+ * disable all crud operations if it is on.
+ * @param eventSource - Source of the logging event.
+ * @param attributes - Free form object of attributes to log.
+ */
+function logCRUDLightningInteraction(eventSource, attributes) {
+    interaction(eventSource, 'force_record', null, eventSource, 'crud', attributes);
+}
+const instrumentation = new Instrumentation();
+
+const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
+//TODO: Some duplication here that can be most likely moved to a util class
+const NO_RECORD_ID_204 = '204_NO_RECORD_ID';
+const NO_RECORD_TYPE_204 = '204_NO_RECORD_TYPE';
+let crudInstrumentationCallbacks = {};
+let crudRLInstrumentationCallbacks = {};
+if (forceRecordTransactionsDisabled === false) {
+    // Record callbacks
+    crudInstrumentationCallbacks = {
+        createRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.CREATE, {
+                // recordId: config.params.recordInput.apiName, // seems wrong?
+                recordId: config.params.recordId || NO_RECORD_ID_204,
+                state: CrudEventState.ERROR,
+            });
+        },
+        createRecordResolveFunction: (config) => {
+            const recordId = config.body ? config.body.id : NO_RECORD_ID_204;
+            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
+            logCRUDLightningInteraction(CrudEventType.CREATE, {
+                recordId,
+                recordType,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        deleteRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.DELETE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        deleteRecordResolveFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.DELETE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        // These should be handled by the network adapater?
+        // getRecordAggregateRejectFunction: (config: InstrumentationRejectConfig) => {
+        //     logCRUDLightningInteraction(CrudEventType.READ, {
+        //         recordId: config.params.recordId,
+        //         state: CrudEventState.ERROR,
+        //     });
+        // },
+        // getRecordAggregateResolveFunction: (config: InstrumentationResolveConfig) => {
+        //     logCRUDLightningInteraction(CrudEventType.READ, {
+        //         recordId: config.params.recordId,
+        //         recordType: config.body.apiName,
+        //         state: CrudEventState.SUCCESS,
+        //     });
+        // },
+        getRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READ, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRecordResolveFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READ, {
+                recordId: config.params.recordId,
+                recordType: config.body.apiName,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        updateRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.UPDATE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        updateRecordResolveFunction: (config) => {
+            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
+            logCRUDLightningInteraction(CrudEventType.UPDATE, {
+                recordId: config.params.recordId,
+                recordType,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+    };
+    // Related list callbacks
+    crudRLInstrumentationCallbacks = {
+        getRelatedListRecordsRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READS, {
+                parentRecordId: config.params.parentRecordId,
+                relatedListId: config.params.relatedListId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRelatedListRecordsResolveFunction: (config) => {
+            logGetRelatedListRecordsInteraction(config.body);
+        },
+        getRelatedListRecordsBatchRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READS, {
+                parentRecordId: config.params.parentRecordId,
+                relatedListIds: config.params.relatedListParameters.map((entry) => entry.relatedListId),
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRelatedListRecordsBatchResolveFunction: (config) => {
+            config.body.results.forEach((res) => {
+                // Log for each RL that was returned from batch endpoint
+                if (res.statusCode === 200) {
+                    logGetRelatedListRecordsInteraction(res.result);
+                }
+            });
+        },
+    };
+}
+// Helper function copied from ui-api
+function logGetRelatedListRecordsInteraction(body) {
+    const records = body.records;
+    // Don't log anything if the related list has no records.
+    if (records.length === 0) {
+        return;
     }
+    const recordIds = records.map((record) => {
+        return record.id;
+    });
     /**
-     * Resets the stat trackers for refresh call events.
+     *  In almost every case - the relatedList records will all be of the same apiName, but there is an edge case for
+        Activities entity that could return Events & Tasks- so handle that case by returning a joined string.
+        ADS Implementation only looks at the first record returned to determine the apiName.
+        See force/recordLibrary/recordMetricsPlugin.js _getRecordType method.
      */
-    resetRefreshStats() {
-        this.refreshAdapterEvents = {};
-        this.refreshApiCallEventStats = {
-            [REFRESH_APEX_KEY]: 0,
-            [REFRESH_UIAPI_KEY]: 0,
-            [SUPPORTED_KEY]: 0,
-            [UNSUPPORTED_KEY]: 0,
-        };
-        this.lastRefreshApiCall = null;
+    logCRUDLightningInteraction(CrudEventType.READS, {
+        parentRecordId: body.listReference.inContextOfRecordId,
+        relatedListId: body.listReference.relatedListId,
+        recordIds,
+        recordType: body.records[0].apiName,
+        state: CrudEventState.SUCCESS,
+    });
+}
+const crudInstrumentationConfig = {
+    records: {
+        post: {
+            rejectFn: crudInstrumentationCallbacks.createRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.createRecordResolveFunction,
+        },
+        get: {
+            rejectFn: crudInstrumentationCallbacks.getRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.getRecordResolveFunction,
+        },
+        patch: {
+            rejectFn: crudInstrumentationCallbacks.updateRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.updateRecordResolveFunction,
+        },
+        delete: {
+            rejectFn: crudInstrumentationCallbacks.deleteRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.deleteRecordResolveFunction,
+        },
+    },
+    relatedListRecords: {
+        post: {
+            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsRejectFunction,
+            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsResolveFunction,
+        },
+    },
+    relatedListRecordsBatch: {
+        post: {
+            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchRejectFunction,
+            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchResolveFunction,
+        },
+    },
+};
+function checkAndLogCrudInteraction(request, isResolve, error, response) {
+    let configPath;
+    const baseUrl = `${request.baseUri}${request.basePath}`;
+    if (baseUrl.startsWith(UIAPI_RECORDS_PATH)) {
+        configPath = crudInstrumentationConfig['records']; // maybe use a constant for this
     }
-    /**
-     * W-7801618
-     * Counter for occurrences where the incoming record to be merged has a different apiName.
-     * Dynamically generated metric, stored in an {@link RecordApiNameChangeCounters} object.
-     *
-     * @param context The transaction context.
-     *
-     * Note: Short-lived metric candidate, remove at the end of 230
-     */
-    incrementRecordApiNameChangeCount(_incomingApiName, existingApiName) {
-        let apiNameChangeCounter = this.recordApiNameChangeCounters[existingApiName];
-        if (apiNameChangeCounter === undefined) {
-            apiNameChangeCounter = counter(createMetricsKey(NAMESPACE, RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME, existingApiName));
-            this.recordApiNameChangeCounters[existingApiName] = apiNameChangeCounter;
-        }
-        apiNameChangeCounter.increment(1);
+    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_BATCH_PATH)) {
+        configPath = crudInstrumentationConfig['relatedListRecordsBatch'];
     }
-    /**
-     * W-8620679
-     * Increment the counter for an UnfulfilledSnapshotError coming from luvio
-     *
-     * @param context The transaction context.
-     */
-    incrementAdapterRequestErrorCount(context) {
-        // We are consolidating all apex adapter instrumentation calls under a single key
-        const adapterName = normalizeAdapterName(context.adapterName);
-        let adapterRequestErrorCounter = this.adapterUnfulfilledErrorCounters[adapterName];
-        if (adapterRequestErrorCounter === undefined) {
-            adapterRequestErrorCounter = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_ERROR_COUNT_METRIC_NAME, adapterName));
-            this.adapterUnfulfilledErrorCounters[adapterName] = adapterRequestErrorCounter;
+    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_PATH)) {
+        configPath = crudInstrumentationConfig['relatedListRecords'];
+    }
+    if (configPath) {
+        const crudCallbacks = configPath[request.method];
+        if (crudCallbacks) {
+            if (isResolve && crudCallbacks.resolveFn) {
+                crudCallbacks.resolveFn(setResolveConfig(request, response));
+            }
+            else if (crudCallbacks.rejectFn) {
+                crudCallbacks.rejectFn(setRejectConfig(request, error));
+            }
         }
-        adapterRequestErrorCounter.increment(1);
-        totalAdapterErrorMetric.increment(1);
     }
 }
-function createMetricsKey(owner, name, unit) {
-    let metricName = name;
-    if (unit) {
-        metricName = metricName + '.' + unit;
-    }
+function setResolveConfig(request, response) {
+    const responseBody = response ? response.body : {};
+    const urlParams = request.urlParams || {};
     return {
-        get() {
-            return { owner: owner, name: metricName };
+        body: responseBody,
+        params: {
+            recordId: urlParams.recordId,
         },
     };
 }
-/**
- * Returns whether adapter is an Apex one or not.
- * @param adapterName The name of the adapter.
- */
-function isApexAdapter(adapterName) {
-    return adapterName.indexOf(APEX_ADAPTER_NAME) > -1;
+function setRejectConfig(request, error) {
+    const requestBody = request.body || {};
+    const urlParams = request.urlParams || {};
+    return {
+        err: error,
+        params: {
+            recordId: urlParams.recordId,
+            // pass these in even if they're undefined
+            parentRecordId: urlParams.parentRecordId,
+            relatedListId: urlParams.relatedListId,
+            relatedListParameters: requestBody.relatedListParameters,
+        },
+    };
 }
+
 /**
- * Normalizes getApex adapter names to `Apex.getApex`. Non-Apex adapters will be prefixed with
- * API family, if supplied. Example: `UiApi.getRecord`.
+ * Builds a Luvio Request interceptor that adds page-scoped cache headers
+ * to ResourceRequest objects used by the Luvio network adapter.
  *
- * Note: If you are adding additional logging that can come from getApex adapter contexts that provide
- * the full getApex adapter name (i.e. getApex_[namespace]_[class]_[function]_[continuation]),
- * ensure to call this method to normalize all logging to 'getApex'. This
- * is because Argus has a 50k key cardinality limit. More context: W-8379680.
+ * This interceptor works with the Luvio ResourceRequest format, which has
+ * a simpler structure than FetchParameters - headers are always a plain object.
  *
- * @param adapterName The name of the adapter.
- * @param apiFamily The API family of the adapter.
- */
-function normalizeAdapterName(adapterName, apiFamily) {
-    if (isApexAdapter(adapterName)) {
-        return NORMALIZED_APEX_ADAPTER_NAME;
-    }
-    return apiFamily ? `${apiFamily}.${adapterName}` : adapterName;
-}
-const timerMetricTracker = create(null);
-/**
- * Calls instrumentation/service telemetry timer
- * @param name Name of the metric
- * @param duration number to update backing percentile histogram, negative numbers ignored
+ * @returns A RequestInterceptor function for Luvio network requests
  */
-function updateTimerMetric(name, duration) {
-    let metric = timerMetricTracker[name];
-    if (metric === undefined) {
-        metric = timer(createMetricsKey(NAMESPACE, name));
-        timerMetricTracker[name] = metric;
-    }
-    timerMetricAddDuration(metric, duration);
-}
-function timerMetricAddDuration(timer, duration) {
-    // Guard against negative values since it causes error to be thrown by MetricsService
-    if (duration >= 0) {
-        timer.addDuration(duration);
-    }
+function buildLuvioPageScopedCacheRequestInterceptor() {
+    return (resourceRequest) => {
+        // Ensure headers object exists
+        if (!resourceRequest.headers) {
+            resourceRequest.headers = {};
+        }
+        // Pass the headers to pageScopedCache which will mutate them
+        pageScopedCache.addHeader(resourceRequest.headers);
+        return resolvedPromiseLike$2(resourceRequest);
+    };
 }
-/**
- * W-10315098
- * Increments the counter associated with the request response. Counts are bucketed by status.
- */
-const requestResponseMetricTracker = create(null);
-function incrementRequestResponseCount(cb) {
-    const status = cb().status;
-    let metric = requestResponseMetricTracker[status];
-    if (metric === undefined) {
-        metric = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, NETWORK_ADAPTER_RESPONSE_METRIC_NAME, `${status.valueOf()}`));
-        requestResponseMetricTracker[status] = metric;
-    }
-    metric.increment();
+
+function buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger) {
+    return async (response) => {
+        if (response.status === 401) {
+            try {
+                const coercedResponse = (await coerceResponseToFetchResponse(response.clone()));
+                if (coercedResponse.body.errorCode === 'INVALID_SESSION_ID') {
+                    logger.warn(`Received ${response.status} status code from LEX runtime service`);
+                    // Fire the event asynchronously, similar to the legacy setTimeout pattern
+                    window.setTimeout(() => {
+                        dispatchGlobalEvent('aura:invalidSession');
+                    }, 0);
+                }
+            }
+            catch (error) {
+                logger.warn(`Error parsing response from LEX runtime service: ${error}`);
+            }
+        }
+        return response;
+    };
 }
-function logObjectInfoChanged() {
-    logObjectInfoChanged$1();
+function buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor() {
+    return async (response) => {
+        if (response.status === 401) {
+            if (response.body.errorCode === 'INVALID_SESSION_ID') {
+                window.setTimeout(() => {
+                    dispatchGlobalEvent('aura:invalidSession');
+                }, 0);
+            }
+        }
+        return response;
+    };
 }
+
 /**
- * Create a new instrumentation cache stats and return it.
+ * Extracts the ErrorId from a server error response message.
+ * Looks for pattern: "ErrorId if you contact support: 1033627214-37969 (-1272663771)"
+ * Returns the numeric value in parentheses.
  *
- * @param name The cache logger name.
- */
-function registerLdsCacheStats(name) {
-    return registerCacheStats(`${NAMESPACE}:${name}`);
-}
-/**
- * Add or overwrite hooks that require aura implementations
+ * @param responseBody The response body text to parse.
+ * @returns The extracted error ID, or null if not found.
  */
-function setAuraInstrumentationHooks() {
-    instrument({
-        recordConflictsResolved: (serverRequestCount) => {
-            // Ignore 0 values which can originate from ADS bridge
-            if (serverRequestCount > 0) {
-                updatePercentileHistogramMetric('record-conflicts-resolved', serverRequestCount);
-            }
-        },
-        nullDisplayValueConflict: ({ fieldType, areValuesEqual }) => {
-            const metricName = `merge-null-dv-count.${fieldType}`;
-            if (fieldType === 'scalar') {
-                incrementCounterMetric(`${metricName}.${areValuesEqual}`);
-            }
-            else {
-                incrementCounterMetric(metricName);
-            }
-        },
-        getRecordNotifyChangeAllowed: incrementGetRecordNotifyChangeAllowCount,
-        getRecordNotifyChangeDropped: incrementGetRecordNotifyChangeDropCount,
-        notifyRecordUpdateAvailableAllowed: incrementNotifyRecordUpdateAvailableAllowCount,
-        notifyRecordUpdateAvailableDropped: incrementNotifyRecordUpdateAvailableDropCount,
-        recordApiNameChanged: instrumentation.incrementRecordApiNameChangeCount.bind(instrumentation),
-        weakEtagZero: instrumentation.aggregateWeakETagEvents.bind(instrumentation),
-        getRecordNotifyChangeNetworkResult: instrumentation.notifyChangeNetwork.bind(instrumentation),
-    });
-    withRegistration('@salesforce/lds-adapters-uiapi', (reg) => setLdsAdaptersUiapiInstrumentation(reg));
-    instrument$1({
-        logCrud: logCRUDLightningInteraction,
-        networkResponse: incrementRequestResponseCount,
-    });
-    instrument$2({
-        error: logError,
-    });
-    instrument$3({
-        refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
-        instrumentAdapter: instrumentation.instrumentAdapter.bind(instrumentation),
-    });
-    instrument$4({
-        timerMetricAddDuration: updateTimerMetric,
-    });
-    // Our getRecord through aggregate-ui CRUD logging has moved
-    // to lds-network-adapter. We still need to respect the
-    // orgs environment setting
-    if (forceRecordTransactionsDisabled$1 === false) {
-        ldsNetworkAdapterInstrument({
-            getRecordAggregateResolve: (cb) => {
-                const { recordId, apiName } = cb();
-                logCRUDLightningInteraction('read', {
-                    recordId,
-                    recordType: apiName,
-                    state: 'SUCCESS',
-                });
-            },
-            getRecordAggregateReject: (cb) => {
-                const recordId = cb();
-                logCRUDLightningInteraction('read', {
-                    recordId,
-                    state: 'ERROR',
-                });
-            },
-        });
+function extractErrorIdFromResponse(responseBody) {
+    try {
+        const parsed = JSON.parse(responseBody);
+        if (Array.isArray(parsed) && parsed.length > 0 && parsed[0].message) {
+            const message = parsed[0].message;
+            // Look for pattern: "ErrorId if you contact support: XXXXXX-XXXXX (YYYYY)"
+            const match = message.match(/ErrorId[^:]*:\s*[\d-]+\s*\((-?\d+)\)/);
+            if (match && match[1]) {
+                return parseInt(match[1], 10);
+            }
+        }
     }
-    withRegistration('@salesforce/lds-network-adapter', (reg) => setLdsNetworkAdapterInstrumentation(reg));
-}
-let stateManagerInstrumentationHooksInitialized = false;
-function setStateManagerInstrumentationHooks() {
-    if (stateManagerInstrumentationHooksInitialized) {
-        return;
+    catch (e) {
+        // If parsing fails, return null to use fallback
     }
-    instrument$5({
-        stateCreated: incrementStateCreatedCount,
-    });
-    stateManagerInstrumentationHooksInitialized = true;
+    return null;
 }
 /**
- * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
+ * Generates a unique error ID for tracking specific error occurrences.
+ * Used as fallback when server doesn't provide an ErrorId.
  *
- * @param luvio The Luvio instance to instrument.
- * @param store The InMemoryStore to instrument.
+ * @param idInput The input value to hash.
+ * @returns A unique error ID in Salesforce-compatible numeric format.
  */
-function setupInstrumentation(luvio, store) {
-    setupInstrumentation$1(luvio, store);
-    setAuraInstrumentationHooks();
-    setStateManagerInstrumentationHooks();
+function generateErrorId(idInput) {
+    let hash = 0;
+    if (!idInput || idInput.length === 0) {
+        return hash;
+    }
+    let i, chr;
+    for (i = 0; i < idInput.length; i++) {
+        chr = idInput.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
 }
 /**
- * Note: locator.scope is set to 'force_record' in order for the instrumentation gate to work, which will
- * disable all crud operations if it is on.
- * @param eventSource - Source of the logging event.
- * @param attributes - Free form object of attributes to log.
+ * Gets error ID from response body or generates a fallback.
+ * Tries to extract server-provided ErrorId first, falls back to generated hash.
+ *
+ * @param responseBody The response body to parse.
+ * @param status The HTTP status code (for fallback).
+ * @param statusText The HTTP status text (for fallback, optional).
+ * @returns A numeric error ID.
  */
-function logCRUDLightningInteraction(eventSource, attributes) {
-    interaction(eventSource, 'force_record', null, eventSource, 'crud', attributes);
+function getOrGenerateErrorId(responseBody, status, statusText) {
+    const extractedId = extractErrorIdFromResponse(responseBody);
+    if (extractedId !== null) {
+        return extractedId;
+    }
+    // Fallback to generated error ID using status and timestamp
+    // statusText is optional and may not always be present
+    const context = [status, statusText || '', Date.now()].join('|');
+    return generateErrorId(context);
 }
-const instrumentation = new Instrumentation();
-
-const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
-//TODO: Some duplication here that can be most likely moved to a util class
-const NO_RECORD_ID_204 = '204_NO_RECORD_ID';
-const NO_RECORD_TYPE_204 = '204_NO_RECORD_TYPE';
-let crudInstrumentationCallbacks = {};
-let crudRLInstrumentationCallbacks = {};
-if (forceRecordTransactionsDisabled === false) {
-    // Record callbacks
-    crudInstrumentationCallbacks = {
-        createRecordRejectFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.CREATE, {
-                // recordId: config.params.recordInput.apiName, // seems wrong?
-                recordId: config.params.recordId || NO_RECORD_ID_204,
-                state: CrudEventState.ERROR,
-            });
-        },
-        createRecordResolveFunction: (config) => {
-            const recordId = config.body ? config.body.id : NO_RECORD_ID_204;
-            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
-            logCRUDLightningInteraction(CrudEventType.CREATE, {
-                recordId,
-                recordType,
-                state: CrudEventState.SUCCESS,
-            });
-        },
-        deleteRecordRejectFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.DELETE, {
-                recordId: config.params.recordId,
-                state: CrudEventState.ERROR,
-            });
-        },
-        deleteRecordResolveFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.DELETE, {
-                recordId: config.params.recordId,
-                state: CrudEventState.SUCCESS,
-            });
-        },
-        // These should be handled by the network adapater?
-        // getRecordAggregateRejectFunction: (config: InstrumentationRejectConfig) => {
-        //     logCRUDLightningInteraction(CrudEventType.READ, {
-        //         recordId: config.params.recordId,
-        //         state: CrudEventState.ERROR,
-        //     });
-        // },
-        // getRecordAggregateResolveFunction: (config: InstrumentationResolveConfig) => {
-        //     logCRUDLightningInteraction(CrudEventType.READ, {
-        //         recordId: config.params.recordId,
-        //         recordType: config.body.apiName,
-        //         state: CrudEventState.SUCCESS,
-        //     });
-        // },
-        getRecordRejectFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.READ, {
-                recordId: config.params.recordId,
-                state: CrudEventState.ERROR,
-            });
-        },
-        getRecordResolveFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.READ, {
-                recordId: config.params.recordId,
-                recordType: config.body.apiName,
-                state: CrudEventState.SUCCESS,
-            });
-        },
-        updateRecordRejectFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.UPDATE, {
-                recordId: config.params.recordId,
-                state: CrudEventState.ERROR,
-            });
-        },
-        updateRecordResolveFunction: (config) => {
-            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
-            logCRUDLightningInteraction(CrudEventType.UPDATE, {
-                recordId: config.params.recordId,
-                recordType,
-                state: CrudEventState.SUCCESS,
-            });
-        },
-    };
-    // Related list callbacks
-    crudRLInstrumentationCallbacks = {
-        getRelatedListRecordsRejectFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.READS, {
-                parentRecordId: config.params.parentRecordId,
-                relatedListId: config.params.relatedListId,
-                state: CrudEventState.ERROR,
-            });
-        },
-        getRelatedListRecordsResolveFunction: (config) => {
-            logGetRelatedListRecordsInteraction(config.body);
-        },
-        getRelatedListRecordsBatchRejectFunction: (config) => {
-            logCRUDLightningInteraction(CrudEventType.READS, {
-                parentRecordId: config.params.parentRecordId,
-                relatedListIds: config.params.relatedListParameters.map((entry) => entry.relatedListId),
-                state: CrudEventState.ERROR,
-            });
-        },
-        getRelatedListRecordsBatchResolveFunction: (config) => {
-            config.body.results.forEach((res) => {
-                // Log for each RL that was returned from batch endpoint
-                if (res.statusCode === 200) {
-                    logGetRelatedListRecordsInteraction(res.result);
-                }
-            });
-        },
+function buildLexRuntime5xxStatusResponseInterceptor(logger) {
+    return async (response) => {
+        if (response.status >= 500 && response.status < 600) {
+            const internalLogMessage = `LEX runtime 5xx: ${response.status} ${response.statusText || ''}`.trim();
+            logger.warn(internalLogMessage);
+            const userMessage = 'A server error occurred. Please try again later.';
+            // Try to extract ErrorId from response body, fallback to generated ID
+            let errorId;
+            try {
+                const responseText = await response.clone().text();
+                errorId = getOrGenerateErrorId(responseText, response.status, response.statusText);
+            }
+            catch (e) {
+                // If reading response fails, use fallback
+                const context = [response.status, response.statusText, Date.now()].join('|');
+                errorId = generateErrorId(context);
+            }
+            // Create an error object similar to Aura's current shape for system errors
+            const error = {
+                message: userMessage,
+                severity: 'ALERT',
+                name: 'LEXRuntimeError',
+                stack: null,
+                handled: false,
+                reported: false,
+                id: errorId,
+            };
+            const evtArgs = {
+                message: error.message,
+                error: null,
+                auraError: error,
+            };
+            // Fire the event asynchronously, similar to the legacy setTimeout pattern
+            window.setTimeout(() => {
+                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
+            }, 0);
+            // Throw a simple error to terminate the request completely
+            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
+            // The systemError event above will handle showing the gack dialog
+            throw new Error(error.message);
+        }
+        return response;
     };
 }
-// Helper function copied from ui-api
-function logGetRelatedListRecordsInteraction(body) {
-    const records = body.records;
-    // Don't log anything if the related list has no records.
-    if (records.length === 0) {
-        return;
+function buildLexRuntimeLuvio5xxStatusResponseInterceptor() {
+    return async (response) => {
+        if (response.status >= 500 && response.status < 600) {
+            const userMessage = 'A server error occurred. Please try again later.';
+            // Try to extract ErrorId from response body, fallback to generated ID
+            let errorId;
+            try {
+                const responseBody = response.body ? JSON.stringify(response.body) : '';
+                errorId = getOrGenerateErrorId(responseBody, response.status, response.statusText);
+            }
+            catch (e) {
+                // If reading response fails, use fallback
+                const context = [response.status, response.statusText, Date.now()].join('|');
+                errorId = generateErrorId(context);
+            }
+            // Create an error object similar to Aura's current shape for system errors
+            const error = {
+                message: userMessage,
+                severity: 'ALERT',
+                name: 'LEXRuntimeError',
+                stack: null,
+                handled: false,
+                reported: false,
+                id: errorId,
+            };
+            const evtArgs = {
+                message: error.message,
+                error: null,
+                auraError: error,
+            };
+            // Fire the event asynchronously, similar to the legacy setTimeout pattern
+            window.setTimeout(() => {
+                dispatchGlobalEvent('markup://aura:systemError', evtArgs);
+            }, 0);
+            // Throw a simple error to terminate the request completely
+            // The consumer has NOT opted in to handle 5xx errors, so we don't return any response
+            // The systemError event above will handle showing the gack dialog
+            throw new Error(error.message);
+        }
+        return response;
+    };
+}
+
+const CSRF_TOKEN_KEY = 'salesforce_csrf_token';
+const CSRF_STORAGE_NAME = 'ldsCSRFToken';
+const CSRF_STORAGE_CONFIG = {
+    name: CSRF_STORAGE_NAME,
+    persistent: true,
+    secure: true,
+    maxSize: 1024,
+    expiration: 24 * 60 * 60,
+    clearOnInit: false,
+    debugLogging: false,
+};
+/**
+ * Manages CSRF token fetching and caching for secure requests.
+ * Implements a singleton pattern to ensure consistent token management across the application.
+ */
+class CsrfTokenManager {
+    constructor() {
+        // Initialize AuraStorage
+        this.storage = createStorage(CSRF_STORAGE_CONFIG);
+        // Try to load token from AuraStorage on initialization
+        this.tokenPromise = this.loadOrFetchToken();
+    }
+    static getInstance() {
+        if (!CsrfTokenManager.instance) {
+            CsrfTokenManager.instance = new CsrfTokenManager();
+        }
+        return CsrfTokenManager.instance;
     }
-    const recordIds = records.map((record) => {
-        return record.id;
-    });
     /**
-     *  In almost every case - the relatedList records will all be of the same apiName, but there is an edge case for
-        Activities entity that could return Events & Tasks- so handle that case by returning a joined string.
-        ADS Implementation only looks at the first record returned to determine the apiName.
-        See force/recordLibrary/recordMetricsPlugin.js _getRecordType method.
+     * Obtain a CSRF token, either from AuraStorage or by fetching a fresh one.
+     *
+     * @private
      */
-    logCRUDLightningInteraction(CrudEventType.READS, {
-        parentRecordId: body.listReference.inContextOfRecordId,
-        relatedListId: body.listReference.relatedListId,
-        recordIds,
-        recordType: body.records[0].apiName,
-        state: CrudEventState.SUCCESS,
-    });
-}
-const crudInstrumentationConfig = {
-    records: {
-        post: {
-            rejectFn: crudInstrumentationCallbacks.createRecordRejectFunction,
-            resolveFn: crudInstrumentationCallbacks.createRecordResolveFunction,
-        },
-        get: {
-            rejectFn: crudInstrumentationCallbacks.getRecordRejectFunction,
-            resolveFn: crudInstrumentationCallbacks.getRecordResolveFunction,
-        },
-        patch: {
-            rejectFn: crudInstrumentationCallbacks.updateRecordRejectFunction,
-            resolveFn: crudInstrumentationCallbacks.updateRecordResolveFunction,
-        },
-        delete: {
-            rejectFn: crudInstrumentationCallbacks.deleteRecordRejectFunction,
-            resolveFn: crudInstrumentationCallbacks.deleteRecordResolveFunction,
-        },
-    },
-    relatedListRecords: {
-        post: {
-            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsRejectFunction,
-            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsResolveFunction,
-        },
-    },
-    relatedListRecordsBatch: {
-        post: {
-            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchRejectFunction,
-            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchResolveFunction,
-        },
-    },
-};
-function checkAndLogCrudInteraction(request, isResolve, error, response) {
-    let configPath;
-    const baseUrl = `${request.baseUri}${request.basePath}`;
-    if (baseUrl.startsWith(UIAPI_RECORDS_PATH)) {
-        configPath = crudInstrumentationConfig['records']; // maybe use a constant for this
+    async loadOrFetchToken() {
+        // First try to get token from AuraStorage
+        if (this.storage) {
+            try {
+                const cachedToken = await this.storage.get(CSRF_TOKEN_KEY);
+                if (typeof cachedToken === 'string' && cachedToken) {
+                    return cachedToken;
+                }
+            }
+            catch {
+                // If storage read fails, continue to fetch
+            }
+        }
+        // No cached token, fetch from server
+        return this.fetchFreshToken();
     }
-    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_BATCH_PATH)) {
-        configPath = crudInstrumentationConfig['relatedListRecordsBatch'];
+    /**
+     * Call API endpoint to acquire a CSRF token and cache it.
+     *
+     * @private
+     */
+    async fetchFreshToken() {
+        try {
+            const response = await fetch('/session/csrf', {
+                method: 'GET',
+                credentials: 'same-origin',
+            });
+            if (!response.ok) {
+                return undefined;
+            }
+            const data = await response.json();
+            const token = data.csrfToken;
+            if (token && this.storage) {
+                // Cache the token in AuraStorage
+                try {
+                    await this.storage.set(CSRF_TOKEN_KEY, token);
+                }
+                catch {
+                    // Non-fatal: token is still available even if caching fails
+                }
+            }
+            return token;
+        }
+        catch {
+            return undefined;
+        }
     }
-    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_PATH)) {
-        configPath = crudInstrumentationConfig['relatedListRecords'];
+    /**
+     * Returns the current token value as a Promise.
+     */
+    async getToken() {
+        return this.tokenPromise;
     }
-    if (configPath) {
-        const crudCallbacks = configPath[request.method];
-        if (crudCallbacks) {
-            if (isResolve && crudCallbacks.resolveFn) {
-                crudCallbacks.resolveFn(setResolveConfig(request, response));
+    /**
+     * Obtains and returns a new token value as a promise.
+     * This will clear the cached token and fetch a fresh one.
+     */
+    async refreshToken() {
+        // Clear cached token
+        if (this.storage) {
+            try {
+                await this.storage.remove(CSRF_TOKEN_KEY);
             }
-            else if (crudCallbacks.rejectFn) {
-                crudCallbacks.rejectFn(setRejectConfig(request, error));
+            catch {
+                // Non-fatal: continue with refresh even if clear fails
             }
         }
+        // Fetch (and cache) fresh token
+        this.tokenPromise = this.fetchFreshToken();
+        return this.tokenPromise;
+    }
+    /**
+     * Reset the singleton instance (useful for testing).
+     * @internal
+     */
+    static resetInstance() {
+        CsrfTokenManager.instance = null;
     }
 }
-function setResolveConfig(request, response) {
-    const responseBody = response ? response.body : {};
-    const urlParams = request.urlParams || {};
-    return {
-        body: responseBody,
-        params: {
-            recordId: urlParams.recordId,
-        },
-    };
-}
-function setRejectConfig(request, error) {
-    const requestBody = request.body || {};
-    const urlParams = request.urlParams || {};
-    return {
-        err: error,
-        params: {
-            recordId: urlParams.recordId,
-            // pass these in even if they're undefined
-            parentRecordId: urlParams.parentRecordId,
-            relatedListId: urlParams.relatedListId,
-            relatedListParameters: requestBody.relatedListParameters,
-        },
-    };
-}
+CsrfTokenManager.instance = null;
 
+const CSRF_TOKEN_HEADER = 'X-CSRF-Token';
 /**
- * Builds a Luvio Request interceptor that adds page-scoped cache headers
- * to ResourceRequest objects used by the Luvio network adapter.
- *
- * This interceptor works with the Luvio ResourceRequest format, which has
- * a simpler structure than FetchParameters - headers are always a plain object.
+ * Determines if the HTTP method requires CSRF protection.
+ * Only mutating operations (POST, PUT, PATCH, DELETE) require CSRF tokens.
  *
- * @returns A RequestInterceptor function for Luvio network requests
+ * @param method - The HTTP method to check
+ * @returns true if the method requires CSRF protection
  */
-function buildLuvioPageScopedCacheRequestInterceptor() {
-    return (resourceRequest) => {
-        // Ensure headers object exists
-        if (!resourceRequest.headers) {
-            resourceRequest.headers = {};
-        }
-        // Pass the headers to pageScopedCache which will mutate them
-        pageScopedCache.addHeader(resourceRequest.headers);
-        return resolvedPromiseLike$3(resourceRequest);
-    };
+function isCsrfMethod(method) {
+    if (!method) {
+        return false;
+    }
+    const normalizedMethod = method.toLowerCase();
+    return (normalizedMethod === 'post' ||
+        normalizedMethod === 'put' ||
+        normalizedMethod === 'patch' ||
+        normalizedMethod === 'delete');
 }
-
-const REQUEST_ID_KEY = 'X-SFDC-Request-Id';
-function buildRequestIdInterceptor() {
+/**
+ * Builds a request interceptor that adds CSRF token headers to mutating requests.
+ * The CSRF token is fetched once and cached for subsequent requests.
+ * Only POST, PUT, PATCH, and DELETE requests will have the CSRF token added.
+ *
+ * @returns A RequestInterceptor function for FetchParameters
+ */
+function buildCsrfTokenInterceptor() {
+    const csrfTokenManager = CsrfTokenManager.getInstance();
     return async (fetchArgs) => {
-        fetchArgs = setHeader(REQUEST_ID_KEY, generateRequestId(), fetchArgs);
-        return resolvedPromiseLike$3(fetchArgs);
+        const [urlOrRequest, options] = fetchArgs;
+        // Determine the method from either Request object or options
+        let method;
+        if (typeof urlOrRequest !== 'string' && 'method' in urlOrRequest) {
+            method = urlOrRequest.method;
+        }
+        else if (options && 'method' in options) {
+            method = options.method;
+        }
+        // Only add CSRF token for mutating operations
+        if (isCsrfMethod(method)) {
+            const token = await csrfTokenManager.getToken();
+            if (token) {
+                fetchArgs = setHeader(CSRF_TOKEN_HEADER, token, fetchArgs);
+            }
+        }
+        return resolvedPromiseLike$2(fetchArgs);
     };
 }
-function buildLuvioRequestIdInterceptor() {
-    return (resourceRequest) => {
+/**
+ * Builds a Luvio request interceptor that adds CSRF token headers to mutating requests.
+ * The CSRF token is fetched once and cached for subsequent requests.
+ * Only POST, PUT, PATCH, and DELETE requests will have the CSRF token added.
+ *
+ * @returns A request interceptor function for Luvio ResourceRequest objects
+ */
+function buildLuvioCsrfTokenInterceptor() {
+    const csrfTokenManager = CsrfTokenManager.getInstance();
+    return async (resourceRequest) => {
         // Ensure headers object exists
         if (!resourceRequest.headers) {
             resourceRequest.headers = {};
         }
-        // Don't overwrite request id header if it already exists
-        if (!resourceRequest.headers[REQUEST_ID_KEY]) {
-            resourceRequest.headers[REQUEST_ID_KEY] = generateRequestId();
+        // Only add CSRF token for mutating operations
+        if (isCsrfMethod(resourceRequest.method)) {
+            // Don't overwrite existing CSRF token header if it already exists
+            if (!resourceRequest.headers[CSRF_TOKEN_HEADER]) {
+                const token = await csrfTokenManager.getToken();
+                if (token) {
+                    resourceRequest.headers[CSRF_TOKEN_HEADER] = token;
+                }
+            }
         }
-        return resolvedPromiseLike$3(resourceRequest);
+        return resolvedPromiseLike$2(resourceRequest);
     };
 }
 
@@ -4907,7 +5965,7 @@ const composedFetchNetworkAdapter = {
         return API_PATH_MATCHERS.some((matcher) => matcher.test(path));
     },
     adapter: setupLexNetworkAdapter(requestTracker, requestLogger, {
-        request: [buildLuvioPageScopedCacheRequestInterceptor(), buildLuvioRequestIdInterceptor()],
+        request: [buildLuvioPageScopedCacheRequestInterceptor(), buildLuvioCsrfTokenInterceptor()],
         response: [
             buildLexRuntimeLuvio5xxStatusResponseInterceptor(),
             buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor(),
@@ -4915,13 +5973,195 @@ const composedFetchNetworkAdapter = {
     }),
 };
 
+function buildThirdPartyTrackerFinishInterceptor() {
+    return async (context) => {
+        if (context && context.instrumentationId) {
+            instrumentationTracker.markFinished(context.instrumentationId);
+        }
+    };
+}
+
+function buildThirdPartyTrackerRegisterInterceptor() {
+    return async (fetchArgs, context) => {
+        if (context && context.instrumentationId) {
+            instrumentationTracker.registerHandler(context.instrumentationId, 'onestore-inflight-network-request', () => {
+                // return false until we signal we are finished
+                return false;
+            });
+        }
+        return resolvedPromiseLike$2(fetchArgs);
+    };
+}
+
+function createInstrumentationIdContext() {
+    return () => ({
+        instrumentationId: generateRequestId$1(),
+    });
+}
+function createStartMark(requestId) {
+    const startMark = markStart('transport', 'request');
+    startMark.context = {
+        auraXHRId: requestId,
+        background: false,
+        actionDefs: ['lds-fetch'],
+        requestId,
+        requestLength: -1, // not known
+    };
+}
+
+function buildPageScopedCacheRequestInterceptor() {
+    return async (fetchArgs) => {
+        const pageScopedCacheHeaders = {};
+        // Allow the instrumentation util to set up the header value on our "dummy" header object
+        pageScopedCache.addHeader(pageScopedCacheHeaders);
+        let returnedFetchArgs = fetchArgs;
+        // If it set a value, add it to our fetchParams
+        Object.entries(pageScopedCacheHeaders).forEach(([key, value]) => {
+            returnedFetchArgs = setHeader(key, value, returnedFetchArgs);
+        });
+        return resolvedPromiseLike$2(returnedFetchArgs);
+    };
+}
+
+const SFDC_REQUEST_ID_KEY = 'X-SFDC-Request-Id';
+function buildTransportMarksSendInterceptor() {
+    return async (fetchArgs, context) => {
+        // First set the requestId header. If there's not context, it means we won't be able to track the mark and something is hosed, and so not worth even trying
+        if (context && context.instrumentationId) {
+            const requestId = context.instrumentationId;
+            fetchArgs = setHeader(SFDC_REQUEST_ID_KEY, requestId, fetchArgs);
+            createStartMark(requestId);
+        }
+        return resolvedPromiseLike$2(fetchArgs);
+    };
+}
+
+function buildTransportMarksReceiveInterceptor() {
+    return async (context) => {
+        if (context && context.instrumentationId) {
+            markEnd('transport', 'request', { auraXHRId: context.instrumentationId });
+        }
+    };
+}
+
+const DEFAULT_CONFIG$1 = {
+    maxRetries: 1, // Only retry once after token refresh
+};
+/**
+ * Retry policy that handles CSRF token expiration errors.
+ *
+ * When a request fails with a CSRF token error this policy will:
+ * 1. Detect the error condition in shouldRetry
+ * 2. Refresh the CSRF token in prepareRetry hook
+ * 3. Update the request headers with the new token via mutable context
+ * 4. Retry the request once (maxRetries = 1)
+ *
+ */
+class CsrfTokenRetryPolicy extends RetryPolicy {
+    constructor(config = DEFAULT_CONFIG$1) {
+        super();
+        this.config = config;
+        this.csrfTokenManager = CsrfTokenManager.getInstance();
+    }
+    /**
+     * Allows the fetch service to pass mutable request context.
+     * This is a side-channel that enables request modification between retries.
+     *
+     * @param context - Mutable container holding fetch arguments
+     */
+    setRequestContext(context) {
+        this.requestContext = context;
+    }
+    /**
+     * Determines if a failed request should be retried due to CSRF token issues.
+     */
+    async shouldRetry(result, context) {
+        // Only retry once
+        if (context.attempt >= this.config.maxRetries) {
+            return false;
+        }
+        // Only retry on 400 status
+        if (result.status !== 400) {
+            return false;
+        }
+        // Check if this is a CSRF error by examining the response body
+        // This avoids retrying all 400s (validation errors, bad requests, etc.)
+        return await isCsrfError(result);
+    }
+    /**
+     * CSRF token refresh should happen immediately with no delay.
+     */
+    async calculateDelay(_result, _context) {
+        return 0; // No delay - retry immediately after token refresh
+    }
+    /**
+     * Called by retry service before each retry attempt.
+     *
+     * This hook is supported by the Conduit retry service (with prepareRetry support).
+     * It performs token refresh and request update:
+     * 1. Refreshes the CSRF token from the server
+     * 2. Updates the mutable request context with the new token
+     *
+     * Note: We already validated this is a CSRF error in shouldRetry,
+     * so we can proceed directly to token refresh.
+     *
+     * The fetch service must call setRequestContext() to provide the mutable args container.
+     * When the retry service re-executes the operation, it will use the updated args.
+     *
+     * @param _result - The failed response that triggered the retry (unused, already validated)
+     * @param _context - Current retry context (unused but part of interface)
+     */
+    async prepareRetry(_result, _context) {
+        // Refresh the CSRF token (we already know this is a CSRF error from shouldRetry)
+        const newToken = await this.csrfTokenManager.refreshToken();
+        if (!newToken || !this.requestContext) {
+            // If we can't get a new token or don't have request context,
+            // the retry will fail again but that's expected
+            return;
+        }
+        // Update the fetch arguments with the new token using the setHeader utility
+        this.requestContext.args = setHeader('X-CSRF-Token', newToken, this.requestContext.args);
+    }
+}
+/**
+ * Helper to check if a response indicates a CSRF token error.
+ *
+ * @param response - The response to check
+ * @returns true if the response indicates a CSRF token error (INVALID_ACCESS_TOKEN)
+ */
+async function isCsrfError(response) {
+    try {
+        // Clone to avoid consuming the original response
+        const cloned = response.clone();
+        const body = await cloned.json();
+        // Check the error array format: data[0].errorCode
+        const errorCode = body?.data?.[0]?.errorCode;
+        return errorCode === 'INVALID_ACCESS_TOKEN';
+    }
+    catch {
+        // If we can't parse the body (network error, non-JSON response, etc.),
+        // assume it's not a CSRF error
+        return false;
+    }
+}
+
 function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
     const fetchService = buildLexConnectFetchServiceDescriptor({
-        request: [buildPageScopedCacheRequestInterceptor(), buildRequestIdInterceptor()],
+        createContext: createInstrumentationIdContext(),
+        request: [
+            buildThirdPartyTrackerRegisterInterceptor(),
+            buildPageScopedCacheRequestInterceptor(),
+            buildTransportMarksSendInterceptor(),
+            buildCsrfTokenInterceptor(),
+        ],
         response: [
             buildLexRuntime5xxStatusResponseInterceptor(logger),
             buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
         ],
+        finally: [
+            buildTransportMarksReceiveInterceptor(),
+            buildThirdPartyTrackerFinishInterceptor(),
+        ],
     }, retryService);
     return {
         ...fetchService,
@@ -4929,38 +6169,69 @@ function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
 }
 function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
     const fetchService = buildLexConnectFetchServiceDescriptor({
-        request: [buildPageScopedCacheRequestInterceptor(), buildRequestIdInterceptor()],
+        createContext: createInstrumentationIdContext(),
+        request: [
+            buildThirdPartyTrackerRegisterInterceptor(),
+            buildPageScopedCacheRequestInterceptor(),
+            buildTransportMarksSendInterceptor(),
+            buildCsrfTokenInterceptor(),
+        ],
         response: [buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger)],
+        finally: [
+            buildTransportMarksReceiveInterceptor(),
+            buildThirdPartyTrackerFinishInterceptor(),
+        ],
     }, retryService);
     return {
         ...fetchService,
         tags: { interceptors: 'allow_500s' },
     };
 }
-function buildLexConnectFetchServiceDescriptor(interceptors = { request: [], response: [] }, retryService) {
+// Temporarily cloned from conduit fetch until the retry service is updated there
+function buildLexConnectFetchServiceDescriptor(interceptors = { request: [], response: [], finally: [] }, retryService) {
     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));
-            const trackerId = generateRequestId();
-            instrumentationTracker.registerHandler(trackerId, 'onestore-inflight-network-request', () => {
-                // return false until we signal we are finished
-                return false;
-            });
+            // Create context per request if factory is provided
+            const context = interceptors.createContext?.();
+            const { request: requestInterceptors = [], response: responseInterceptors = [], finally: finallyInterceptors = [], } = interceptors;
+            const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((args) => interceptor(args, context)), resolvedPromiseLike$2(args));
             return Promise.resolve(pending)
-                .then((args) => {
+                .then((interceptedArgs) => {
                 if (retryService) {
-                    return retryService.applyRetry(() => fetch(...args));
+                    // Create mutable context for CSRF retry policy
+                    const mutableRequest = { args: interceptedArgs };
+                    // Pass context to CSRF policy if it's being used
+                    const policy = retryService.defaultRetryPolicy;
+                    // Handle both direct CSRF policy and composed policy
+                    if (policy instanceof CsrfTokenRetryPolicy) {
+                        policy.setRequestContext(mutableRequest);
+                    }
+                    else if (policy instanceof ComposedRetryPolicy) {
+                        // Extract CSRF policy from composed policy
+                        const csrfPolicy = policy.getPolicyByType(CsrfTokenRetryPolicy);
+                        if (csrfPolicy) {
+                            csrfPolicy.setRequestContext(mutableRequest);
+                        }
+                    }
+                    // Retry service will call prepareRetry hook which updates mutableRequest.args
+                    return retryService.applyRetry(async () => {
+                        return await fetch(...mutableRequest.args);
+                    });
                 }
-                return fetch(...args);
+                return fetch(...interceptedArgs);
             })
                 .then((response) => {
-                return responseInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(interceptor), resolvedPromiseLike$3(response));
+                // Success path - run response interceptors
+                return responseInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((response) => interceptor(response, context)), resolvedPromiseLike$2(response));
             })
                 .finally(() => {
-                instrumentationTracker.markFinished(trackerId);
+                // Always run finally interceptors for cleanup
+                if (finallyInterceptors.length > 0) {
+                    // Run all finally interceptors sequentially
+                    return finallyInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(() => interceptor(context)), Promise.resolve());
+                }
             });
         },
     };
@@ -4971,7 +6242,9 @@ const sfapJwtRepository = new JwtRepository();
 const sfapJwtManager = new JwtManager(sfapJwtRepository, platformSfapJwtResolver);
 function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
     const jwtAuthorizedFetchService = buildLexConnectFetchServiceDescriptor({
-        request: [buildJwtRequestInterceptor(logger)],
+        createContext: createInstrumentationIdContext(),
+        request: [buildThirdPartyTrackerRegisterInterceptor(), buildJwtRequestInterceptor(logger)],
+        finally: [buildThirdPartyTrackerFinishInterceptor()],
     });
     return {
         ...jwtAuthorizedFetchService,
@@ -4990,7 +6263,9 @@ function buildCopilotFetchServiceDescriptor(logger) {
         // Interceptor here with the logic in buildJwtAuthorizedSfapFetchServiceDescriptor()
         // above.
         ...buildLexConnectFetchServiceDescriptor({
+            createContext: createInstrumentationIdContext(),
             request: [
+                buildThirdPartyTrackerRegisterInterceptor(),
                 // 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.
@@ -5003,9 +6278,9 @@ function buildCopilotFetchServiceDescriptor(logger) {
                         requestInit.method !== 'POST' ||
                         !requestInit.body ||
                         typeof requestInit.body !== 'string') {
-                        return resolvedPromiseLike$3(args);
+                        return resolvedPromiseLike$2(args);
                     }
-                    return resolvedPromiseLike$3(sfapJwtManager.getJwt()).then((token) => {
+                    return resolvedPromiseLike$2(sfapJwtManager.getJwt()).then((token) => {
                         // replace the body's instanceConfig.endpoint with the JWT's iss value
                         const body = JSON.parse(requestInit.body);
                         if (!body || !token.decodedInfo || !token.decodedInfo.iss) {
@@ -5030,12 +6305,17 @@ function buildCopilotFetchServiceDescriptor(logger) {
                 },
                 buildJwtRequestInterceptor(logger),
             ],
+            finally: [buildThirdPartyTrackerFinishInterceptor()],
         }),
         tags: { specialHacksFor: 'copilot' },
     };
 }
 function buildUnauthorizedFetchServiceDescriptor() {
-    const fetchService = buildLexConnectFetchServiceDescriptor();
+    const fetchService = buildLexConnectFetchServiceDescriptor({
+        createContext: createInstrumentationIdContext(),
+        request: [buildThirdPartyTrackerRegisterInterceptor()],
+        finally: [buildThirdPartyTrackerFinishInterceptor()],
+    });
     return {
         ...fetchService,
         tags: { authenticationScopes: '' },
@@ -7785,12 +9065,12 @@ class FetchThrottlingRetryPolicy extends RetryPolicy {
         super();
         this.config = config;
     }
-    shouldRetry(result, context) {
+    async shouldRetry(result, context) {
         return ((result.status === 429 || result.status === 503) &&
             context.attempt < this.config.maxRetries &&
             context.totalElapsedMs <= this.config.maxTimeToRetry);
     }
-    calculateDelay(result, context) {
+    async calculateDelay(result, context) {
         let delay;
         // If retry-after header is present and valid, use it
         const retryAfterHeader = this.parseRetryAfterHeader(result);
@@ -8407,18 +9687,18 @@ function initializeLDS() {
 }
 // Initializes OneStore in LEX
 function initializeOneStore(luvio) {
-    const loggerService = new ConsoleLogger$1('ERROR');
-    const cacheServiceDescriptor = buildServiceDescriptor$a();
-    const instrumentationServiceDescriptor = buildServiceDescriptor$b(loggerService);
+    const loggerService = new ConsoleLogger('ERROR');
+    const cacheServiceDescriptor = buildServiceDescriptor$h();
+    const instrumentationServiceDescriptor = buildServiceDescriptor$i(loggerService);
     const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
     const durableCacheInclusionPolicyServiceDescriptor = buildAuraDurableCacheInclusionPolicyService();
     const durableCacheControlService = {
-        ...buildServiceDescriptor$9(cacheServiceDescriptor.service, durableCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
+        ...buildServiceDescriptor$g(cacheServiceDescriptor.service, durableCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
         tags: { storage: 'durable' },
     };
-    const featureFlagsServiceDescriptor = buildServiceDescriptor$3();
+    const featureFlagsServiceDescriptor = buildServiceDescriptor$a();
     const featureFlagsService = featureFlagsServiceDescriptor.service;
-    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$2((configs) => {
+    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$9((configs) => {
         return notifyUpdateAvailableFactory(luvio)(configs);
     }, (recordId, reader) => {
         const recordKey = buildRecordRepKeyFromId(recordId);
@@ -8437,8 +9717,11 @@ function initializeOneStore(luvio) {
         reader.unMarkMissing();
         return linkedData.data;
     });
-    const retryPolicy = new FetchThrottlingRetryPolicy();
-    const retryServiceDescriptor = buildServiceDescriptor$1(retryPolicy);
+    // Compose both throttling and CSRF retry policies
+    const throttlingPolicy = new FetchThrottlingRetryPolicy();
+    const csrfPolicy = new CsrfTokenRetryPolicy();
+    const retryPolicy = new ComposedRetryPolicy([throttlingPolicy, csrfPolicy]);
+    const retryServiceDescriptor = buildServiceDescriptor$8(retryPolicy);
     const retryService = retryServiceDescriptor.service;
     // set flags based on gates
     featureFlagsService.set('useOneStoreGraphQL', useOneStoreGraphql.isOpen({ fallback: false }));
@@ -8449,27 +9732,36 @@ function initializeOneStore(luvio) {
         buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
         buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
-        buildServiceDescriptor$c(instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$j(instrumentationServiceDescriptor.service),
         // Ordering of services matters - L1 only CacheControlService must come before durable
-        buildServiceDescriptor$9(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$g(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
         durableCacheControlService,
-        buildServiceDescriptor$j(),
-        buildServiceDescriptor$7(),
-        buildServiceDescriptor$f(),
-        buildServiceDescriptor$k(),
+        buildServiceDescriptor$q(),
         buildServiceDescriptor$e(),
-        buildServiceDescriptor$d(),
-        buildServiceDescriptor$i(),
-        buildServiceDescriptor$h(),
-        buildServiceDescriptor$g(),
-        buildServiceDescriptor$8(),
+        buildServiceDescriptor$m(),
+        buildServiceDescriptor$r(),
+        buildServiceDescriptor$l(),
+        buildServiceDescriptor$k(),
+        buildServiceDescriptor$p(),
+        buildServiceDescriptor$o(),
+        buildServiceDescriptor$n(),
+        buildServiceDescriptor$f(),
         buildLexRuntimeAllow5xxFetchServiceDescriptor(loggerService, retryService),
-        buildServiceDescriptor$6(luvio),
+        buildServiceDescriptor$d(luvio),
         luvioUiapiRecordsServiceDescriptor,
-        buildServiceDescriptor$5(),
-        buildServiceDescriptor$4(),
+        buildServiceDescriptor$c(),
+        buildServiceDescriptor$b(),
         featureFlagsServiceDescriptor,
         retryServiceDescriptor,
+        buildServiceDescriptor$6(),
+        buildServiceDescriptor$5(),
+        buildServiceDescriptor$4(),
+        buildServiceDescriptor$3(),
+        buildServiceDescriptor$2$1(),
+        buildServiceDescriptor$1$1(),
+        buildServiceDescriptor$7(),
+        buildLWCWireBindingsServiceDescriptor(),
+        buildLWCGraphQLWireBindingsServiceDescriptor(),
     ];
     setServices(services);
 }
@@ -8489,4 +9781,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.401.0-b1adb82748
+// version: 1.403.0-bc09fbc54b