@salesforce/lds-runtime-aura 1.401.0 → 1.402.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 { pageScopedCache } from 'instrumentation/utility';
+import { instrument as instrument$2, generateRequestId as generateRequestId$1, setupLexNetworkAdapter, internalRequestTracker } 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 { 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.402.0-566b6c5389
 
 /*!
  * 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.402.0-566b6c5389
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3025,44 +3015,923 @@ class RetryService {
   constructor(defaultRetryPolicy) {
     this.defaultRetryPolicy = defaultRetryPolicy;
   }
-  applyRetry(operation, retryPolicyOverride) {
-    return this.retry(operation, retryPolicyOverride || this.defaultRetryPolicy);
+  applyRetry(operation, retryPolicyOverride) {
+    return this.retry(operation, retryPolicyOverride || this.defaultRetryPolicy);
+  }
+  async retry(operation, policy) {
+    const startTime = Date.now();
+    let attempt = 0;
+    let result = await operation();
+    let context = {
+      attempt,
+      totalElapsedMs: Date.now() - startTime,
+      lastResult: result
+    };
+    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 = {
+        attempt,
+        totalElapsedMs: Date.now() - startTime,
+        lastResult: result
+      };
+    }
+    return result;
+  }
+  delay(ms) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+}
+class RetryPolicy {
+}
+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),
+    type: "retry"
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function isUserVisibleError(error) {
+  return error instanceof Error && "type" in error && error.type === "user-visible";
+}
+function throwUserlandError(error) {
+  logError(error);
+  throw buildUserlandError(error);
+}
+function emitError(callback, error) {
+  logError(error);
+  callback({ data: void 0, error: buildUserlandError(error) });
+}
+function buildUserlandError(error) {
+  if (isUserVisibleError(error)) {
+    return error.data;
+  }
+  return new Error("Internal error in Lightning Data Service adapter occurred.");
+}
+function logError(error) {
+  if (isUserVisibleError(error)) {
+    return;
+  }
+  console.error("OneStore Command threw an error that we did not expect", error);
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function buildBaseImperativeInvoker(getCommand, transformResult) {
+  return async (...params) => {
+    const command = getCommand({ params, assertIsValid });
+    try {
+      return command.execute().then((result) => transformResult(result));
+    } catch (error) {
+      throwUserlandError(error);
+    }
+  };
+}
+const supportedCachePolicyTypes = ["no-cache", "only-if-cached"];
+function requestContextIsSupportedCachePolicy(requestContext) {
+  return typeof requestContext === "object" && requestContext !== null && "cachePolicy" in requestContext && typeof requestContext.cachePolicy === "object" && requestContext.cachePolicy !== null && "type" in requestContext.cachePolicy && typeof requestContext.cachePolicy.type === "string" && supportedCachePolicyTypes.includes(
+    requestContext.cachePolicy.type
+  );
+}
+function getOverridesForLegacyRequestContext(requestContext) {
+  if (requestContextIsSupportedCachePolicy(requestContext)) {
+    return { cacheControlConfig: { type: requestContext.cachePolicy.type } };
+  }
+  return {};
+}
+function handleEmit(res, callback) {
+  const consumerEmittedData = {
+    data: void 0,
+    errors: void 0
+  };
+  if (res.isOk()) {
+    consumerEmittedData.data = res.value.data;
+  } else {
+    const { data, errors } = toGraphQLResponseFromFailure$1(res.error);
+    consumerEmittedData.data = data;
+    consumerEmittedData.errors = errors;
+  }
+  callback(consumerEmittedData);
+}
+function toGraphQLResponseFromFailure$1(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
+  }
+  logError$1(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
+}
+class DefaultImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? result.value.data : result.value;
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
+  }
+}
+function buildServiceDescriptor$6() {
+  return {
+    type: "defaultImperativeBindings",
+    version: "1.0",
+    service: new DefaultImperativeBindingsService()
+  };
+}
+class QueryImperativeBindingsService {
+  bind(getCommand) {
+    return buildBaseImperativeInvoker(getCommand, (result) => {
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        return isSubscribableResult(result) ? { data: result.value.data } : { data: result.value };
+      }
+      throw toError(isSubscribableResult(result) ? result.error.failure : result.error);
+    });
+  }
+}
+function buildServiceDescriptor$5() {
+  return {
+    type: "queryImperativeBindings",
+    version: "1.0",
+    service: new QueryImperativeBindingsService()
+  };
+}
+class SubscribableImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return buildBaseImperativeInvoker(
+      getCommand,
+      (result) => this.transformResult(result, exposeRefresh)
+    );
+  }
+  transformResult(result, exposeRefresh = false) {
+    if (!isSubscribableResult(result)) {
+      console.error(
+        "Non-subscribable result encountered - please use correct operation type"
+      );
+      throw new Error("Internal error in Lightning Data Service adapter occurred");
+    }
+    if (result.isOk()) {
+      deepFreeze(result.value.data);
+      const api = {
+        data: result.value.data,
+        subscribe: (cb) => {
+          result.value.subscribe((result2) => {
+            if (result2.isErr()) {
+              return cb({ data: void 0, error: toError(result2.error) });
+            }
+            return cb({ data: result2.value, error: void 0 });
+          });
+        }
+      };
+      if (exposeRefresh) {
+        return {
+          ...api,
+          refresh: () => {
+            return result.value.refresh().then((res) => {
+              if (res.isOk()) {
+                return void 0;
+              }
+              throw res.error;
+            });
+          }
+        };
+      } else {
+        return api;
+      }
+    } else {
+      throw toError(result.error.failure);
+    }
+  }
+}
+function buildServiceDescriptor$4() {
+  return {
+    type: "subscribableImperativeBindings",
+    version: "1.0",
+    service: new SubscribableImperativeBindingsService()
+  };
+}
+class LegacyImperativeBindingsService {
+  bind(getCommand) {
+    const invoke = async (config, requestContext, callback) => {
+      const command = getCommand({ config, assertIsValid });
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        const result = await command.execute(overrides);
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          callback({ data: result.value.data, error: void 0 });
+        } else {
+          callback({ data: void 0, error: toError(result.error.failure) });
+        }
+      } catch (error) {
+        emitError(callback, error);
+      }
+    };
+    const subscribe = (config, requestContext, callback) => {
+      const command = getCommand({ config, assertIsValid });
+      let unsubscribe = () => {
+      };
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        command.execute(overrides).then(
+          (result) => {
+            if (!result.isOk()) {
+              callback({ data: void 0, error: toError(result.error.failure) });
+              return;
+            }
+            unsubscribe = result.value.subscribe((res) => {
+              if (res.isOk()) {
+                callback({ data: res.value, error: void 0 });
+              } else {
+                callback({ data: void 0, error: toError(res.error) });
+              }
+            });
+            callback({ data: result.value.data, error: void 0 });
+          },
+          (e) => {
+            emitError(callback, e);
+          }
+        );
+      } catch (e) {
+        emitError(callback, e);
+      }
+      return () => {
+        unsubscribe();
+      };
+    };
+    return { invoke, subscribe };
+  }
+}
+function buildServiceDescriptor$3() {
+  return {
+    type: "legacyImperativeBindings",
+    version: "1.0",
+    service: new LegacyImperativeBindingsService()
+  };
+}
+class GraphQLImperativeBindingsService {
+  bind(getCommand, exposeRefresh = false) {
+    return async (...params) => {
+      try {
+        if (params.length) {
+          params[0] = wrapConfigAndVerify(params[0]);
+        }
+        return await buildBaseImperativeInvoker(getCommand, (result) => this.transformResult(result, exposeRefresh))(...params);
+      } catch (error) {
+        logError$1(error);
+        return {
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        };
+      }
+    };
+  }
+  transformResult(result, exposeRefresh = false) {
+    const consumerEmittedData = {
+      data: void 0,
+      errors: void 0
+    };
+    if (result.isOk()) {
+      deepFreeze(result.value);
+      consumerEmittedData.data = result.value.data.data;
+      consumerEmittedData.subscribe = (cb) => {
+        result.value.subscribe((res) => {
+          const consumerEmittedData2 = {
+            data: void 0,
+            errors: void 0
+          };
+          if (res.isOk()) {
+            consumerEmittedData2.data = res.value.data;
+          } else {
+            if (isUserVisibleError$1(res.error)) {
+              consumerEmittedData2.data = res.error.data.data;
+              consumerEmittedData2.errors = res.error.data.errors;
+            } else {
+              logError$1(res.error);
+              consumerEmittedData2.errors = [
+                {
+                  message: "Internal error in GraphQL adapter occurred",
+                  locations: []
+                }
+              ];
+            }
+          }
+          cb(consumerEmittedData2);
+        });
+      };
+      if (exposeRefresh) {
+        consumerEmittedData.refresh = () => {
+          return new Promise((resolve, reject) => {
+            try {
+              result.value.refresh().then((res) => {
+                if (res.isOk()) {
+                  resolve();
+                } else {
+                  reject(
+                    new Error(
+                      "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                    )
+                  );
+                }
+              });
+            } catch (error) {
+              logError$1(error);
+              reject(
+                new Error(
+                  "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                )
+              );
+            }
+          });
+        };
+      }
+    } else {
+      const resp = toGraphQLResponseFromFailure$1(result.error.failure);
+      consumerEmittedData.data = resp.data;
+      consumerEmittedData.errors = resp.errors;
+    }
+    return consumerEmittedData;
+  }
+}
+function buildServiceDescriptor$2$1() {
+  return {
+    type: "graphQLImperativeBindings",
+    version: "1.0",
+    service: new GraphQLImperativeBindingsService()
+  };
+}
+class GraphQLLegacyImperativeBindingsService {
+  bind(getCommand) {
+    const invoke = async (config, requestContext, callback) => {
+      config = wrapConfigAndVerify(config);
+      const command = getCommand({ config, assertIsValid });
+      try {
+        const overrides = getOverridesForLegacyRequestContext(requestContext);
+        const result = await command.execute(overrides);
+        const consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          consumerEmittedData.data = result.value.data.data;
+        } else {
+          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
+          consumerEmittedData.data = data;
+          consumerEmittedData.errors = errors;
+        }
+        callback(consumerEmittedData);
+      } catch (error) {
+        logError$1(error);
+        callback({
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        });
+      }
+    };
+    const subscribe = (config, requestContext, callback) => {
+      config = wrapConfigAndVerify(config);
+      const command = getCommand({ config, assertIsValid });
+      let unsubscribe = () => {
+      };
+      const overrides = getOverridesForLegacyRequestContext(requestContext);
+      command.execute(overrides).then((result) => {
+        const consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          consumerEmittedData.data = result.value.data.data;
+          unsubscribe = result.value.subscribe(
+            (res) => {
+              handleEmit(res, callback);
+            }
+          );
+        } else {
+          const { data, errors } = toGraphQLResponseFromFailure$1(result.error.failure);
+          consumerEmittedData.data = data;
+          consumerEmittedData.errors = errors;
+          unsubscribe = result.error.subscribe(
+            (res) => {
+              handleEmit(res, callback);
+            }
+          );
+        }
+        callback(consumerEmittedData);
+      });
+      return () => {
+        unsubscribe();
+      };
+    };
+    return { invoke, subscribe };
+  }
+}
+function buildServiceDescriptor$1$1() {
+  return {
+    type: "graphQLLegacyImperativeBindings",
+    version: "1.0",
+    service: new GraphQLLegacyImperativeBindingsService()
+  };
+}
+class GraphQLMutationBindingsService {
+  bind(getCommand) {
+    return async (...params) => {
+      try {
+        if (params.length) {
+          params[0] = wrapConfigAndVerify(params[0], {
+            acceptedOperations: ["mutation"]
+          });
+        }
+        const command = getCommand({ params, assertIsValid });
+        const result = await command.execute({ cacheControlConfig: { type: "no-cache" } });
+        if (result.isOk()) {
+          deepFreeze(result.value);
+          return result.value.data;
+        } else {
+          return toGraphQLResponseFromFailure$1(result.error.failure);
+        }
+      } catch (error) {
+        logError$1(error);
+        return {
+          data: void 0,
+          errors: [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ]
+        };
+      }
+    };
+  }
+}
+function buildServiceDescriptor$7() {
+  return {
+    type: "graphQLMutationBindings",
+    version: "1.0",
+    service: new GraphQLMutationBindingsService()
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class Sanitizer {
+  constructor(obj) {
+    this.obj = obj;
+    this.copy = {};
+    this.currentPath = {
+      key: "",
+      value: obj,
+      parent: null,
+      data: this.copy
+    };
+  }
+  sanitize() {
+    const sanitizer = this;
+    JSON.stringify(this.obj, function(key, value) {
+      if (key === "") {
+        return value;
+      }
+      const parent = this;
+      if (parent !== sanitizer.currentPath.value) {
+        sanitizer.exit(parent);
+      }
+      if (typeof value === "object" && value !== null) {
+        sanitizer.enter(key, value);
+        return value;
+      }
+      sanitizer.currentPath.data[key] = value;
+      return value;
+    });
+    return this.copy;
+  }
+  enter(key, value) {
+    const { currentPath: parentPath } = this;
+    const data = parentPath.data[key] = Array.isArray(value) ? [] : {};
+    this.currentPath = {
+      key,
+      value,
+      parent: parentPath,
+      data
+    };
+  }
+  exit(parent) {
+    while (this.currentPath.value !== parent) {
+      this.currentPath = this.currentPath.parent || this.currentPath;
+    }
+  }
+}
+function sanitize(obj) {
+  return new Sanitizer(obj).sanitize();
+}
+function isIncompleteConfigError(err) {
+  return err instanceof MissingRequiredPropertyError || err instanceof JsonSchemaViolationError && err.validationErrors.find(
+    (validationError) => validationError instanceof MissingRequiredPropertyError
+  ) !== void 0;
+}
+class CommandWireAdapterConstructor {
+  constructor(callback, sourceContext, options) {
+    this.callback = callback;
+    this.connected = false;
+    this.exposeRefresh = false;
+    if (!(options == null ? void 0 : options.skipEmptyEmit)) {
+      this.emit();
+    }
+  }
+  connect() {
+    this.connected = true;
+    this.invokeAdapter();
+  }
+  disconnect() {
+    this.unsubscribe();
+    this.connected = false;
+  }
+  update(config, _context) {
+    this.unsubscribe();
+    this.config = sanitize(config);
+    this.invokeAdapter();
+  }
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, error: void 0 });
+      } else {
+        const consumerEmittedRefresh = () => {
+          if (!this.refresh) {
+            return Promise.resolve();
+          }
+          return new Promise((resolve, reject) => {
+            if (!this.refresh) {
+              resolve();
+              return;
+            }
+            this.refresh().then((res) => {
+              if (res.isOk()) {
+                resolve();
+              } else {
+                reject(
+                  new Error(
+                    "Internal error in Lightning Data Service adapter occurred: Failed to refresh data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          error: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          if (isSubscribableResult(result)) {
+            consumerEmittedData.error = result.error.failure;
+          } else {
+            consumerEmittedData.error = result.error;
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            deepFreeze(result.value.data);
+            consumerEmittedData.data = result.value.data;
+          } else {
+            deepFreeze(result.value);
+            consumerEmittedData.data = result.value;
+          }
+        }
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  invokeAdapter() {
+    if (!this.connected || this.config === void 0) {
+      return;
+    }
+    if (this.configSchema) {
+      try {
+        assertIsValid(this.config, this.configSchema);
+      } catch (err) {
+        if (isIncompleteConfigError(err)) {
+          return;
+        }
+        throw err;
+      }
+    }
+    const initialConfig = this.config;
+    const command = this.getCommand();
+    try {
+      command.execute().then((result) => {
+        if (!this.connected || this.config !== initialConfig) {
+          return;
+        }
+        this.refresh = void 0;
+        if (result.isOk()) {
+          if (isSubscribableResult(result)) {
+            const value = result.value;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(ok$2(value.data));
+          } else {
+            this.emit(result);
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            const value = result.error;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(result);
+          } else {
+            this.unsubscriber = () => {
+            };
+            this.emit(result);
+          }
+        }
+      });
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(error) {
+    emitError(this.callback, error);
   }
-  async retry(operation, policy) {
-    const startTime = Date.now();
-    let attempt = 0;
-    let result = await operation();
-    let context = {
-      attempt,
-      totalElapsedMs: Date.now() - startTime,
-      lastResult: result
+  unsubscribe() {
+    if (this.unsubscriber) {
+      this.unsubscriber();
+      delete this.unsubscriber;
+    }
+  }
+}
+function toGraphQLResponseFromFailure(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
     };
-    while (policy.shouldRetry(result, context)) {
-      const delay = policy.calculateDelay(result, context);
-      await this.delay(delay);
-      attempt++;
-      result = await operation();
-      context = {
-        attempt,
-        totalElapsedMs: Date.now() - startTime,
-        lastResult: result
-      };
+  }
+  logError$1(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
+}
+class LWCWireBindingsService {
+  bind(getCommand, configSchema, exposeRefresh = false) {
+    return class extends CommandWireAdapterConstructor {
+      constructor() {
+        super(...arguments);
+        this.configSchema = configSchema;
+        this.exposeRefresh = exposeRefresh;
+      }
+      getCommand() {
+        return getCommand(this.config);
+      }
+    };
+  }
+}
+function buildServiceDescriptor$1() {
+  return {
+    type: "lwcWireBindings",
+    version: "1.0",
+    service: new LWCWireBindingsService()
+  };
+}
+class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, errors: void 0 });
+      } else {
+        const consumerEmittedRefresh = () => {
+          if (!this.refresh) {
+            return Promise.resolve();
+          }
+          return new Promise((resolve, reject) => {
+            if (!this.refresh) {
+              resolve();
+              return;
+            }
+            this.refresh().then((res) => {
+              if (res.isOk()) {
+                resolve();
+              } else {
+                reject(
+                  new Error(
+                    "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          const failure = isSubscribableResult(result) ? result.error.failure : result.error;
+          const resp = toGraphQLResponseFromFailure(failure);
+          consumerEmittedData.data = resp.data;
+          consumerEmittedData.errors = resp.errors;
+        } else {
+          consumerEmittedData.data = result.value.data;
+        }
+        deepFreeze(consumerEmittedData);
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      logError$1(e);
+      this.handleExecutionThrow(e);
     }
-    return result;
   }
-  delay(ms) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, ms);
+  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 RetryPolicy {
+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$1(defaultRetryPolicy) {
+function buildServiceDescriptor$2() {
   return {
+    type: "lwcGraphQLWireBindings",
     version: "1.0",
-    service: new RetryService(defaultRetryPolicy),
-    type: "retry"
+    service: new LWCGraphQLWireBindingsService()
   };
 }
 
@@ -3119,50 +3988,6 @@ function o(e2, r2) {
   }
 }
 n$1.prototype = new Error(), n$1.prototype.name = "InvalidTokenError";
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-const LogLevelMap = {
-  TRACE: 4,
-  DEBUG: 3,
-  INFO: 2,
-  WARN: 1,
-  ERROR: 0
-};
-class ConsoleLogger {
-  constructor(level = "WARN", printer = console.log, formatter = (level2, message) => `${level2}: ${message}`) {
-    this.level = level;
-    this.printer = printer;
-    this.formatter = formatter;
-    this.messages = [];
-  }
-  trace(message) {
-    this.log("TRACE", message);
-  }
-  debug(message) {
-    this.log("DEBUG", message);
-  }
-  info(message) {
-    this.log("INFO", message);
-  }
-  warn(message) {
-    this.log("WARN", message);
-  }
-  error(message) {
-    this.log("ERROR", message);
-  }
-  log(level, message) {
-    if (LogLevelMap[level] > LogLevelMap[this.level]) {
-      return;
-    }
-    this.printer(this.formatter(level, message));
-  }
-}
-function loggerService(level, printer, formatter) {
-  return new ConsoleLogger(level, printer, formatter);
-}
 class JwtToken {
   /**
    * Create a new JwtToken.
@@ -3445,7 +4270,7 @@ function setHeaderAuthorization({ token }, fetchParams) {
 }
 function buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier = (_e, fetchArgs) => fetchArgs) {
   return (args) => {
-    return resolvedPromiseLike$3(jwtManager.getJwt()).then((token) => {
+    return resolvedPromiseLike$2(jwtManager.getJwt()).then((token) => {
       const fetchArgsWithRequestHeaderAuthorization = setHeaderAuthorization(token, args);
       return token.extraInfo ? jwtRequestModifier(token.extraInfo, fetchArgsWithRequestHeaderAuthorization) : fetchArgsWithRequestHeaderAuthorization;
     });
@@ -3653,6 +4478,7 @@ function generateHeaders(headers) {
 }
 
 const SALESFORCE_API_BASE_URI_FLAG = 'api.salesforce.com';
+const X_REQUEST_ID_HEADER = 'x-request-id';
 const SFAPController = 'SalesforceApiPlatformController';
 const SFAPJwtMethod = 'getSFAPLightningJwtService';
 /**
@@ -3733,6 +4559,8 @@ const modifySfapResourceRequest = function (resourceRequest, jwtToken) {
         baseUri,
     };
 };
+// used for instrumentation and tracking
+let sfapRequestCount = 0;
 const sfapNetworkAdapter = async (resourceRequest, resourceRequestContext) => {
     let jwtToken;
     try {
@@ -3746,7 +4574,32 @@ const sfapNetworkAdapter = async (resourceRequest, resourceRequestContext) => {
     }
     let authenticatedRequest = authenticateRequest(resourceRequest, jwtToken);
     authenticatedRequest = modifySfapResourceRequest(authenticatedRequest, jwtToken);
-    return fetchNetworkAdapter(authenticatedRequest);
+    // --- 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) {
@@ -3762,6 +4615,17 @@ const composedNetworkAdapter$1 = {
     },
     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";
 
@@ -3959,7 +4823,7 @@ function buildPageScopedCacheRequestInterceptor() {
         Object.entries(pageScopedCacheHeaders).forEach(([key, value]) => {
             returnedFetchArgs = setHeader(key, value, returnedFetchArgs);
         });
-        return resolvedPromiseLike$3(returnedFetchArgs);
+        return resolvedPromiseLike$2(returnedFetchArgs);
     };
 }
 
@@ -4001,7 +4865,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.401.0-c620f9ffed
+// version: 1.402.0-566b6c5389
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -4526,7 +5390,7 @@ function setAuraInstrumentationHooks() {
         networkResponse: incrementRequestResponseCount,
     });
     instrument$2({
-        error: logError,
+        error: logError$2,
     });
     instrument$3({
         refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
@@ -4821,15 +5685,15 @@ function buildLuvioPageScopedCacheRequestInterceptor() {
         }
         // Pass the headers to pageScopedCache which will mutate them
         pageScopedCache.addHeader(resourceRequest.headers);
-        return resolvedPromiseLike$3(resourceRequest);
+        return resolvedPromiseLike$2(resourceRequest);
     };
 }
 
 const REQUEST_ID_KEY = 'X-SFDC-Request-Id';
 function buildRequestIdInterceptor() {
     return async (fetchArgs) => {
-        fetchArgs = setHeader(REQUEST_ID_KEY, generateRequestId(), fetchArgs);
-        return resolvedPromiseLike$3(fetchArgs);
+        fetchArgs = setHeader(REQUEST_ID_KEY, generateRequestId$1(), fetchArgs);
+        return resolvedPromiseLike$2(fetchArgs);
     };
 }
 function buildLuvioRequestIdInterceptor() {
@@ -4840,9 +5704,198 @@ function buildLuvioRequestIdInterceptor() {
         }
         // Don't overwrite request id header if it already exists
         if (!resourceRequest.headers[REQUEST_ID_KEY]) {
-            resourceRequest.headers[REQUEST_ID_KEY] = generateRequestId();
+            resourceRequest.headers[REQUEST_ID_KEY] = generateRequestId$1();
+        }
+        return resolvedPromiseLike$2(resourceRequest);
+    };
+}
+
+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;
+    }
+    /**
+     * Obtain a CSRF token, either from AuraStorage or by fetching a fresh one.
+     *
+     * @private
+     */
+    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();
+    }
+    /**
+     * 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;
+        }
+    }
+    /**
+     * Returns the current token value as a Promise.
+     */
+    async getToken() {
+        return this.tokenPromise;
+    }
+    /**
+     * 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);
+            }
+            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;
+    }
+}
+CsrfTokenManager.instance = null;
+
+const CSRF_TOKEN_HEADER = 'X-CSRF-Token';
+/**
+ * Determines if the HTTP method requires CSRF protection.
+ * Only mutating operations (POST, PUT, PATCH, DELETE) require CSRF tokens.
+ *
+ * @param method - The HTTP method to check
+ * @returns true if the method requires CSRF protection
+ */
+function isCsrfMethod(method) {
+    if (!method) {
+        return false;
+    }
+    const normalizedMethod = method.toLowerCase();
+    return (normalizedMethod === 'post' ||
+        normalizedMethod === 'put' ||
+        normalizedMethod === 'patch' ||
+        normalizedMethod === 'delete');
+}
+/**
+ * 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) => {
+        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);
+    };
+}
+/**
+ * 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 = {};
         }
-        return resolvedPromiseLike$3(resourceRequest);
+        // 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$2(resourceRequest);
     };
 }
 
@@ -4907,7 +5960,11 @@ const composedFetchNetworkAdapter = {
         return API_PATH_MATCHERS.some((matcher) => matcher.test(path));
     },
     adapter: setupLexNetworkAdapter(requestTracker, requestLogger, {
-        request: [buildLuvioPageScopedCacheRequestInterceptor(), buildLuvioRequestIdInterceptor()],
+        request: [
+            buildLuvioPageScopedCacheRequestInterceptor(),
+            buildLuvioRequestIdInterceptor(),
+            buildLuvioCsrfTokenInterceptor(),
+        ],
         response: [
             buildLexRuntimeLuvio5xxStatusResponseInterceptor(),
             buildLexRuntimeLuvioAuthExpirationRedirectResponseInterceptor(),
@@ -4915,9 +5972,114 @@ const composedFetchNetworkAdapter = {
     }),
 };
 
+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()],
+        request: [
+            buildPageScopedCacheRequestInterceptor(),
+            buildRequestIdInterceptor(),
+            buildCsrfTokenInterceptor(),
+        ],
         response: [
             buildLexRuntime5xxStatusResponseInterceptor(logger),
             buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
@@ -4929,7 +6091,11 @@ function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
 }
 function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
     const fetchService = buildLexConnectFetchServiceDescriptor({
-        request: [buildPageScopedCacheRequestInterceptor(), buildRequestIdInterceptor()],
+        request: [
+            buildPageScopedCacheRequestInterceptor(),
+            buildRequestIdInterceptor(),
+            buildCsrfTokenInterceptor(),
+        ],
         response: [buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger)],
     }, retryService);
     return {
@@ -4943,21 +6109,39 @@ function buildLexConnectFetchServiceDescriptor(interceptors = { request: [], res
         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();
+            const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(interceptor), resolvedPromiseLike$2(args));
+            const trackerId = generateRequestId$1();
             instrumentationTracker.registerHandler(trackerId, 'onestore-inflight-network-request', () => {
                 // return false until we signal we are finished
                 return false;
             });
             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));
+                return responseInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(interceptor), resolvedPromiseLike$2(response));
             })
                 .finally(() => {
                 instrumentationTracker.markFinished(trackerId);
@@ -5003,9 +6187,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) {
@@ -7785,12 +8969,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 +9591,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 +9621,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 +9636,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(),
+        buildServiceDescriptor$1(),
+        buildServiceDescriptor$2(),
     ];
     setServices(services);
 }
@@ -8489,4 +9685,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.401.0-b1adb82748
+// version: 1.402.0-bf9ae185ef