@salesforce/lds-runtime-aura 1.400.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';
 
@@ -51,15 +52,16 @@ 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$2, parse: parse$1 } = JSON;
-const LogLevelMap$1 = {
+const { stringify: stringify$3, parse: parse$2 } = JSON;
+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) {
@@ -179,7 +184,7 @@ function stableJSONStringify$2(node) {
     return isFinite(node) ? "" + node : "null";
   }
   if (typeof node !== "object") {
-    return stringify$2(node);
+    return stringify$3(node);
   }
   let i;
   let out;
@@ -207,7 +212,7 @@ function stableJSONStringify$2(node) {
     if (out) {
       out += ",";
     }
-    out += stringify$2(key) + ":" + value;
+    out += stringify$3(key) + ":" + value;
   }
   return "{" + out + "}";
 }
@@ -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$j() {
+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$i() {
+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$h() {
+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(
-        err$1(new Error(`Failed to build data from type: ${stringify$2(data.error)}`))
+      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$g() {
+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(
-        err$1(new Error(`Failed to build data from type: ${stringify$2(data.error)}`))
+      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$f() {
+function buildServiceDescriptor$n() {
   return {
     type: "httpNormalizedCacheControlCommand",
     version: "1.0",
@@ -1537,7 +1569,7 @@ _FetchNetworkCommand.availableDecorators = {
   abortable: createAbortableDecorator
 };
 let FetchNetworkCommand = _FetchNetworkCommand;
-function buildServiceDescriptor$e() {
+function buildServiceDescriptor$m() {
   return {
     type: "fetchNetworkCommandBaseClass",
     version: "1.0",
@@ -1573,7 +1605,7 @@ class StreamingCommand extends BaseCommand {
     );
   }
 }
-function buildServiceDescriptor$d() {
+function buildServiceDescriptor$l() {
   return {
     type: "streamingCommandBaseClass",
     version: "1.0",
@@ -1656,7 +1688,7 @@ class SSEParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$c() {
+function buildServiceDescriptor$k() {
   return {
     type: "SSECommandBaseClass",
     version: "1.0",
@@ -1707,7 +1739,7 @@ function buildInstrumentCommand(services) {
     };
   };
 }
-function buildServiceDescriptor$b(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$a(logger) {
+function buildServiceDescriptor$i(logger) {
   return {
     type: "instrumentation",
     version: "1.0",
@@ -1995,12 +2027,12 @@ function buildServiceDescriptor$a(logger) {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-const { stringify: stringify$1, parse } = JSON;
-function deepCopy(x) {
-  const stringified = stringify$1(x);
-  return stringified ? parse(stringified) : void 0;
+const { stringify: stringify$2, parse: parse$1 } = JSON;
+function deepCopy$1(x) {
+  const stringified = stringify$2(x);
+  return stringified ? parse$1(stringified) : void 0;
 }
-class DefaultRecordableCache {
+let DefaultRecordableCache$1 = class DefaultRecordableCache {
   constructor(baseCache) {
     this.baseCache = baseCache;
     this.keysRead = /* @__PURE__ */ new Set();
@@ -2019,7 +2051,7 @@ class DefaultRecordableCache {
       this.missingKeysRead.add(key);
     }
     if (options == null ? void 0 : options.copy) {
-      return deepCopy(value);
+      return deepCopy$1(value);
     }
     return value;
   }
@@ -2045,13 +2077,13 @@ class DefaultRecordableCache {
     return new DefaultRecordableCache(this);
   }
   filter(predicate) {
-    return new DefaultFilteredCache(this, predicate);
+    return new DefaultFilteredCache$1(this, predicate);
   }
   buildFixedTimeWritableCache(generatedTime) {
-    return new FixedTimeWritableCache(this, generatedTime);
+    return new FixedTimeWritableCache$1(this, generatedTime);
   }
-}
-class DefaultFilteredCache {
+};
+let DefaultFilteredCache$1 = class DefaultFilteredCache {
   constructor(baseCache, predicate) {
     this.baseCache = baseCache;
     this.predicate = predicate;
@@ -2063,7 +2095,7 @@ class DefaultFilteredCache {
     const result = this.baseCache.get(key);
     if (result && this.predicate(key, result)) {
       if (options == null ? void 0 : options.copy) {
-        return deepCopy(result);
+        return deepCopy$1(result);
       }
       return result;
     }
@@ -2085,7 +2117,7 @@ class DefaultFilteredCache {
     return this.getFilteredEntries();
   }
   record() {
-    return new DefaultRecordableCache(this);
+    return new DefaultRecordableCache$1(this);
   }
   filter(predicate) {
     return new DefaultFilteredCache(this, predicate);
@@ -2105,10 +2137,10 @@ class DefaultFilteredCache {
     return filteredKeySet;
   }
   buildFixedTimeWritableCache(generatedTime) {
-    return new FixedTimeWritableCache(this, generatedTime);
+    return new FixedTimeWritableCache$1(this, generatedTime);
   }
-}
-class FixedTimeWritableCache {
+};
+let FixedTimeWritableCache$1 = class FixedTimeWritableCache {
   constructor(baseCache, generatedTime) {
     this.baseCache = baseCache;
     this.generatedTime = generatedTime;
@@ -2144,22 +2176,22 @@ class FixedTimeWritableCache {
     return this.baseCache.entries();
   }
   record() {
-    return new DefaultRecordableCache(this);
+    return new DefaultRecordableCache$1(this);
   }
   filter(predicate) {
-    return new DefaultFilteredCache(this, predicate);
+    return new DefaultFilteredCache$1(this, predicate);
   }
   buildFixedTimeWritableCache(generatedTime) {
     return new FixedTimeWritableCache(this, generatedTime);
   }
-}
-class DefaultCache {
+};
+let DefaultCache$1 = class DefaultCache {
   constructor() {
     this.data = {};
   }
   get(key, options) {
     if (options == null ? void 0 : options.copy) {
-      return deepCopy(this.data[key]);
+      return deepCopy$1(this.data[key]);
     }
     return this.data[key];
   }
@@ -2221,20 +2253,20 @@ class DefaultCache {
     return Object.entries(this.data);
   }
   record() {
-    return new DefaultRecordableCache(this);
+    return new DefaultRecordableCache$1(this);
   }
   filter(predicate) {
-    return new DefaultFilteredCache(this, predicate);
+    return new DefaultFilteredCache$1(this, predicate);
   }
   buildFixedTimeWritableCache(generatedTime) {
-    return new FixedTimeWritableCache(this, generatedTime);
+    return new FixedTimeWritableCache$1(this, generatedTime);
   }
-}
-function buildServiceDescriptor$9() {
+};
+function buildServiceDescriptor$h() {
   return {
     type: "cache",
     version: "1.0",
-    service: new DefaultCache()
+    service: new DefaultCache$1()
   };
 }
 
@@ -2453,7 +2485,7 @@ class CacheController {
     yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
   }
 }
-function buildServiceDescriptor$8(cache, cacheInclusionPolicy, instrumentation) {
+function buildServiceDescriptor$g(cache, cacheInclusionPolicy, instrumentation) {
   return {
     type: "cacheController",
     version: "1.0",
@@ -2466,48 +2498,6 @@ function buildServiceDescriptor$8(cache, cacheInclusionPolicy, instrumentation)
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-/*!
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-function resolvedPromiseLike$1(result) {
-  if (isPromiseLike$1(result)) {
-    return result.then((nextResult) => nextResult);
-  }
-  return {
-    then: (onFulfilled, _onRejected) => {
-      try {
-        return resolvedPromiseLike$1(onFulfilled(result));
-      } catch (e) {
-        if (onFulfilled === void 0) {
-          return resolvedPromiseLike$1(result);
-        }
-        return rejectedPromiseLike$1(e);
-      }
-    }
-  };
-}
-function rejectedPromiseLike$1(reason) {
-  if (isPromiseLike$1(reason)) {
-    return reason.then((nextResult) => nextResult);
-  }
-  return {
-    then: (_onFulfilled, onRejected) => {
-      if (typeof onRejected === "function") {
-        try {
-          return resolvedPromiseLike$1(onRejected(reason));
-        } catch (e) {
-          return rejectedPromiseLike$1(e);
-        }
-      }
-      return rejectedPromiseLike$1(reason);
-    }
-  };
-}
-function isPromiseLike$1(x) {
-  return typeof (x == null ? void 0 : x.then) === "function";
-}
 const EventTypeWildcard = Symbol("EventTypeWildcard");
 class DefaultPubSubService {
   constructor() {
@@ -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$7() {
+function buildServiceDescriptor$f() {
   return {
     type: "pubSub",
     version: "1.0",
@@ -2626,7 +2616,7 @@ class NDJSONParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$6() {
+function buildServiceDescriptor$e() {
   return {
     type: "NDJSONCommandBaseClass",
     version: "1.0",
@@ -2667,7 +2657,7 @@ function buildServiceDescriptor$6() {
  * };
  * ```
  */
-function buildServiceDescriptor$5(luvio) {
+function buildServiceDescriptor$d(luvio) {
     return {
         type: 'luvio',
         version: '1.0',
@@ -2676,7 +2666,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.400.0-3c7514a502
+// 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$4() {
+function buildServiceDescriptor$c() {
   return {
     type: "auraGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2958,7 +2948,7 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
     });
   }
 }
-function buildServiceDescriptor$3() {
+function buildServiceDescriptor$b() {
   return {
     type: "httpGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2982,7 +2972,7 @@ class FeatureFlagsService {
     return this.flags.get(flagName) || defaultValue;
   }
 }
-function buildServiceDescriptor$2() {
+function buildServiceDescriptor$a() {
   return {
     version: "1.0",
     service: new FeatureFlagsService(),
@@ -3004,7 +2994,7 @@ function buildServiceDescriptor$2() {
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
+function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
     return {
         type: 'luvioUiapiRecords',
         version: '1.0',
@@ -3014,7 +3004,7 @@ function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.400.0-3c7514a502
+// version: 1.402.0-566b6c5389
 
 /*!
  * 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(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,98 +3166,828 @@ function buildServiceDescriptor(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 = [];
+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 } };
   }
-  trace(message) {
-    this.log("TRACE", 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;
   }
-  debug(message) {
-    this.log("DEBUG", message);
+  callback(consumerEmittedData);
+}
+function toGraphQLResponseFromFailure$1(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
   }
-  info(message) {
-    this.log("INFO", message);
+  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);
+    });
   }
-  warn(message) {
-    this.log("WARN", message);
+}
+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);
+    });
   }
-  error(message) {
-    this.log("ERROR", message);
+}
+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)
+    );
   }
-  log(level, message) {
-    if (LogLevelMap[level] > LogLevelMap[this.level]) {
+  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;
     }
-    this.printer(this.formatter(level, message));
+    if (this.configSchema) {
+      try {
+        assertIsValid(this.config, this.configSchema);
+      } catch (err) {
+        if (isIncompleteConfigError(err)) {
+          return;
+        }
+        throw err;
+      }
+    }
+    const initialConfig = this.config;
+    const command = this.getCommand();
+    try {
+      command.execute().then((result) => {
+        if (!this.connected || this.config !== initialConfig) {
+          return;
+        }
+        this.refresh = void 0;
+        if (result.isOk()) {
+          if (isSubscribableResult(result)) {
+            const value = result.value;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(ok$2(value.data));
+          } else {
+            this.emit(result);
+          }
+        } else {
+          if (isSubscribableResult(result)) {
+            const value = result.error;
+            this.unsubscriber = value.subscribe((updatedResult) => {
+              if (!this.connected || this.config !== initialConfig) {
+                this.unsubscribe();
+                return;
+              }
+              this.emit(updatedResult);
+            });
+            this.refresh = value.refresh;
+            this.emit(result);
+          } else {
+            this.unsubscriber = () => {
+            };
+            this.emit(result);
+          }
+        }
+      });
+    } catch (e) {
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(error) {
+    emitError(this.callback, error);
+  }
+  unsubscribe() {
+    if (this.unsubscriber) {
+      this.unsubscriber();
+      delete this.unsubscriber;
+    }
   }
 }
-function loggerService(level, printer, formatter) {
-  return new ConsoleLogger(level, printer, formatter);
+function toGraphQLResponseFromFailure(failure) {
+  if (isUserVisibleError$1(failure)) {
+    return {
+      data: failure.data.data,
+      errors: failure.data.errors
+    };
+  }
+  logError$1(failure);
+  return {
+    data: void 0,
+    errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+  };
+}
+class LWCWireBindingsService {
+  bind(getCommand, configSchema, exposeRefresh = false) {
+    return class extends CommandWireAdapterConstructor {
+      constructor() {
+        super(...arguments);
+        this.configSchema = configSchema;
+        this.exposeRefresh = exposeRefresh;
+      }
+      getCommand() {
+        return getCommand(this.config);
+      }
+    };
+  }
+}
+function buildServiceDescriptor$1() {
+  return {
+    type: "lwcWireBindings",
+    version: "1.0",
+    service: new LWCWireBindingsService()
+  };
+}
+class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
+  emit(result) {
+    try {
+      if (result === void 0) {
+        this.callback({ data: void 0, errors: void 0 });
+      } else {
+        const consumerEmittedRefresh = () => {
+          if (!this.refresh) {
+            return Promise.resolve();
+          }
+          return new Promise((resolve, reject) => {
+            if (!this.refresh) {
+              resolve();
+              return;
+            }
+            this.refresh().then((res) => {
+              if (res.isOk()) {
+                resolve();
+              } else {
+                reject(
+                  new Error(
+                    "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                  )
+                );
+              }
+            });
+          });
+        };
+        let consumerEmittedData = {
+          data: void 0,
+          errors: void 0
+        };
+        if (this.exposeRefresh && this.refresh) {
+          consumerEmittedData.refresh = consumerEmittedRefresh;
+        }
+        if (result.isErr()) {
+          const failure = isSubscribableResult(result) ? result.error.failure : result.error;
+          const resp = toGraphQLResponseFromFailure(failure);
+          consumerEmittedData.data = resp.data;
+          consumerEmittedData.errors = resp.errors;
+        } else {
+          consumerEmittedData.data = result.value.data;
+        }
+        deepFreeze(consumerEmittedData);
+        this.callback(consumerEmittedData);
+      }
+    } catch (e) {
+      logError$1(e);
+      this.handleExecutionThrow(e);
+    }
+  }
+  handleExecutionThrow(e) {
+    logError$1(e);
+    this.callback({
+      data: void 0,
+      errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+    });
+  }
+  update(config, _context) {
+    this.unsubscribe();
+    const resolvedQuery = resolveAst(config.query);
+    if (resolvedQuery) {
+      validateGraphQLOperations(
+        { query: resolvedQuery, operationName: config == null ? void 0 : config.operationName },
+        { acceptedOperations: ["query"] }
+      );
+    }
+    this.config = {
+      ...sanitize(config),
+      query: resolvedQuery
+    };
+    this.invokeAdapter();
+  }
+}
+class LWCGraphQLWireBindingsService {
+  bind(getCommand, configSchema, exposeRefresh = false) {
+    return class extends GraphQLCommandWireAdapterConstructor {
+      constructor() {
+        super(...arguments);
+        this.configSchema = configSchema;
+        this.exposeRefresh = exposeRefresh;
+      }
+      getCommand() {
+        return getCommand(this.config);
+      }
+    };
+  }
 }
+function buildServiceDescriptor$2() {
+  return {
+    type: "lwcGraphQLWireBindings",
+    version: "1.0",
+    service: new LWCGraphQLWireBindingsService()
+  };
+}
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+function e$1(e2) {
+  this.message = e2;
+}
+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 n$1(e2) {
+  this.message = e2;
+}
+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);
+  }
+}
+n$1.prototype = new Error(), n$1.prototype.name = "InvalidTokenError";
 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.400.0-3c7514a502
+// version: 1.402.0-566b6c5389
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -4051,7 +4915,7 @@ const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = {
 
 const { create, keys, hasOwnProperty, entries } = Object;
 const { isArray, from } = Array;
-const { stringify } = JSON;
+const { stringify: stringify$1 } = JSON;
 
 /**
  * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
@@ -4077,7 +4941,7 @@ function stableJSONStringify$1(node) {
         return isFinite(node) ? '' + node : 'null';
     }
     if (typeof node !== 'object') {
-        return stringify(node);
+        return stringify$1(node);
     }
     let i;
     let out;
@@ -4108,7 +4972,7 @@ function stableJSONStringify$1(node) {
         if (out) {
             out += ',';
         }
-        out += stringify(key) + ':' + value;
+        out += stringify$1(key) + ':' + value;
     }
     return '{' + out + '}';
 }
@@ -4526,7 +5390,7 @@ function setAuraInstrumentationHooks() {
         networkResponse: incrementRequestResponseCount,
     });
     instrument$2({
-        error: logError,
+        error: logError$2,
     });
     instrument$3({
         refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
@@ -4821,28 +5685,217 @@ 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() {
+    return (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$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);
     };
 }
-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 +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) {
@@ -6001,7 +7185,7 @@ function stableJSONStringify(node) {
         return isFinite(node) ? '' + node : 'null';
     }
     if (typeof node !== 'object') {
-        return stringify(node);
+        return stringify$1(node);
     }
     let i;
     let out;
@@ -6029,7 +7213,7 @@ function stableJSONStringify(node) {
         if (out) {
             out += ',';
         }
-        out += stringify(key) + ':' + value;
+        out += stringify$1(key) + ':' + value;
     }
     return '{' + out + '}';
 }
@@ -7295,50 +8479,356 @@ class Ok {
   constructor(value) {
     this.value = value;
   }
-  isOk() {
-    return true;
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+}
+const ok = (value) => new Ok(value);
+function setDifference(setA, setB) {
+  const differenceSet = /* @__PURE__ */ new Set();
+  for (const element of setA) {
+    if (!setB.has(element)) {
+      differenceSet.add(element);
+    }
+  }
+  return differenceSet;
+}
+function resolvedPromiseLike(result) {
+  if (isPromiseLike(result)) {
+    return result.then((nextResult) => nextResult);
+  }
+  return {
+    then: (onFulfilled, _onRejected) => {
+      try {
+        return resolvedPromiseLike(onFulfilled(result));
+      } catch (e) {
+        if (onFulfilled === void 0) {
+          return resolvedPromiseLike(result);
+        }
+        return rejectedPromiseLike(e);
+      }
+    }
+  };
+}
+function rejectedPromiseLike(reason) {
+  if (isPromiseLike(reason)) {
+    return reason.then((nextResult) => nextResult);
+  }
+  return {
+    then: (_onFulfilled, onRejected) => {
+      if (typeof onRejected === "function") {
+        try {
+          return resolvedPromiseLike(onRejected(reason));
+        } catch (e) {
+          return rejectedPromiseLike(e);
+        }
+      }
+      return rejectedPromiseLike(reason);
+    }
+  };
+}
+function isPromiseLike(x) {
+  return typeof (x == null ? void 0 : x.then) === "function";
+}
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+const { stringify, parse } = JSON;
+function deepCopy(x) {
+  const stringified = stringify(x);
+  return stringified ? parse(stringified) : void 0;
+}
+class DefaultRecordableCache {
+  constructor(baseCache) {
+    this.baseCache = baseCache;
+    this.keysRead = /* @__PURE__ */ new Set();
+    this.missingKeysRead = /* @__PURE__ */ new Set();
+    this.keysUpdated = /* @__PURE__ */ new Set();
+    this.metadataKeysUpdated = /* @__PURE__ */ new Set();
+  }
+  delete(key) {
+    this.keysUpdated.add(key);
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    this.keysRead.add(key);
+    const value = this.baseCache.get(key);
+    if (value === void 0) {
+      this.missingKeysRead.add(key);
+    }
+    if (options == null ? void 0 : options.copy) {
+      return deepCopy(value);
+    }
+    return value;
+  }
+  set(key, value) {
+    this.keysUpdated.add(key);
+    this.metadataKeysUpdated.add(key);
+    this.baseCache.set(key, value);
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.metadataKeysUpdated.add(key);
+    this.baseCache.setMetadata(key, cacheControlMetadata);
+  }
+  length() {
+    return this.baseCache.length();
+  }
+  keys() {
+    return this.baseCache.keys();
+  }
+  entries() {
+    return this.baseCache.entries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class DefaultFilteredCache {
+  constructor(baseCache, predicate) {
+    this.baseCache = baseCache;
+    this.predicate = predicate;
+  }
+  delete(key) {
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    const result = this.baseCache.get(key);
+    if (result && this.predicate(key, result)) {
+      if (options == null ? void 0 : options.copy) {
+        return deepCopy(result);
+      }
+      return result;
+    }
+    return void 0;
+  }
+  set(key, value) {
+    this.baseCache.set(key, value);
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.baseCache.setMetadata(key, cacheControlMetadata);
+  }
+  length() {
+    return this.getFilteredKeys().size;
+  }
+  keys() {
+    return this.getFilteredKeys();
+  }
+  entries() {
+    return this.getFilteredEntries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  getFilteredEntries() {
+    return this.baseCache.entries().filter(([key, _value]) => {
+      return this.get(key);
+    });
+  }
+  getFilteredKeys() {
+    const filteredKeySet = /* @__PURE__ */ new Set();
+    this.baseCache.keys().forEach((key) => {
+      if (this.get(key)) {
+        filteredKeySet.add(key);
+      }
+    });
+    return filteredKeySet;
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class FixedTimeWritableCache {
+  constructor(baseCache, generatedTime) {
+    this.baseCache = baseCache;
+    this.generatedTime = generatedTime;
+  }
+  delete(key) {
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    return this.baseCache.get(key, options);
+  }
+  set(key, value) {
+    this.baseCache.set(key, {
+      ...value,
+      metadata: {
+        ...value.metadata,
+        cacheControl: { ...value.metadata.cacheControl, generatedTime: this.generatedTime }
+      }
+    });
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.baseCache.setMetadata(key, {
+      ...cacheControlMetadata,
+      generatedTime: this.generatedTime
+    });
+  }
+  length() {
+    return this.baseCache.length();
   }
-  isErr() {
-    return !this.isOk();
+  keys() {
+    return this.baseCache.keys();
+  }
+  entries() {
+    return this.baseCache.entries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
   }
 }
-const ok = (value) => new Ok(value);
-function resolvedPromiseLike(result) {
-  if (isPromiseLike(result)) {
-    return result.then((nextResult) => nextResult);
+class DefaultCache {
+  constructor() {
+    this.data = {};
   }
-  return {
-    then: (onFulfilled, _onRejected) => {
-      try {
-        return resolvedPromiseLike(onFulfilled(result));
-      } catch (e) {
-        if (onFulfilled === void 0) {
-          return resolvedPromiseLike(result);
-        }
-        return rejectedPromiseLike(e);
-      }
+  get(key, options) {
+    if (options == null ? void 0 : options.copy) {
+      return deepCopy(this.data[key]);
     }
-  };
-}
-function rejectedPromiseLike(reason) {
-  if (isPromiseLike(reason)) {
-    return reason.then((nextResult) => nextResult);
+    return this.data[key];
   }
-  return {
-    then: (_onFulfilled, onRejected) => {
-      if (typeof onRejected === "function") {
-        try {
-          return resolvedPromiseLike(onRejected(reason));
-        } catch (e) {
-          return rejectedPromiseLike(e);
+  /**
+   * Adds the specified key/value to the cache.
+   *
+   * @param key key at which to store value
+   * @param entry value to be stored
+   */
+  set(key, entry) {
+    if (entry.metadata.cacheControl.type === "no-store") {
+      return;
+    }
+    this.data[key] = {
+      ...entry,
+      metadata: {
+        ...entry.metadata,
+        type: entry.metadata.type || {
+          namespace: "OneStore:Internal",
+          name: "UnknownType"
+        },
+        cacheControl: {
+          generatedTime: Date.now() / 1e3,
+          ...entry.metadata.cacheControl
         }
       }
-      return rejectedPromiseLike(reason);
+    };
+  }
+  /**
+   * Removes the cache entry associated with the specified key.
+   *
+   * @param key key to be removed from the store
+   */
+  delete(key) {
+    delete this.data[key];
+  }
+  /**
+   * Sets the metadata for the specified key if the key is in cache.
+   * If the key doesn't exist, it does nothing.
+   *
+   * @param key key at which to store metadata
+   * @param cacheControlMetadata metadata to be stored
+   */
+  setMetadata(key, cacheControlMetadata) {
+    if (key in this.data) {
+      this.data[key].metadata.cacheControl = {
+        generatedTime: Date.now() / 1e3,
+        ...cacheControlMetadata
+      };
     }
+  }
+  length() {
+    return this.keys().size;
+  }
+  keys() {
+    return new Set(Object.keys(this.data));
+  }
+  entries() {
+    return Object.entries(this.data);
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+function buildServiceDescriptor() {
+  return {
+    type: "cache",
+    version: "1.0",
+    service: new DefaultCache()
   };
 }
-function isPromiseLike(x) {
-  return typeof (x == null ? void 0 : x.then) === "function";
+class DurableCacheInclusionPolicy extends CacheInclusionPolicyService {
+  /**
+   * Reads data out of a 2 level inclusive store.
+   */
+  read(options) {
+    const { l1, readFromL1, alreadyRevivedKeys } = options;
+    const recordableCache = l1.record();
+    return readFromL1(recordableCache).then((readResult) => {
+      if (readResult.isOk()) {
+        return readResult;
+      }
+      const keysToRevive = recordableCache.keysRead;
+      if (alreadyRevivedKeys && setDifference(keysToRevive, alreadyRevivedKeys).size === 0) {
+        return readResult;
+      }
+      return this.revive(keysToRevive, l1).then((revivedKeys) => {
+        if (setDifference(keysToRevive, revivedKeys).size > 0) {
+          return readResult;
+        }
+        return this.read({ l1, readFromL1, alreadyRevivedKeys: revivedKeys });
+      });
+    });
+  }
+  /**
+   * Writes data to a 2 level inclusive store.
+   */
+  write(options) {
+    const { l1, writeToL1 } = options;
+    const tempL1 = buildServiceDescriptor().service.record();
+    return writeToL1(tempL1).then(() => {
+      const keysToReviveRecordableCache = l1.record();
+      tempL1.keysUpdated.forEach((key) => keysToReviveRecordableCache.get(key));
+      tempL1.missingKeysRead.forEach((key) => keysToReviveRecordableCache.get(key));
+      const missingKeys = keysToReviveRecordableCache.missingKeysRead;
+      const revivePromiseLike = missingKeys.size > 0 ? this.revive(missingKeys, l1).then(() => void 0) : resolvedPromiseLike(void 0);
+      return revivePromiseLike.then(() => {
+        const recordableCache = l1.record();
+        return writeToL1(recordableCache).then((result) => {
+          this.syncToL2Cache(recordableCache.keysUpdated, l1);
+          return result;
+        });
+      });
+    });
+  }
 }
 const isAndQuery = (query) => "$and" in query;
 const isOrQuery = (query) => "$or" in query;
@@ -7479,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);
@@ -7533,6 +9023,314 @@ class FetchThrottlingRetryPolicy extends RetryPolicy {
     }
 }
 
+/**
+ * Default storage configuration for the durable cache
+ */
+const DEFAULT_STORAGE_CONFIG = {
+    name: 'ldsDurableCache',
+    persistent: true,
+    secure: true,
+    maxSize: 10 * 1024 * 1024,
+    expiration: 30 * 24 * 60 * 60,
+    clearOnInit: false,
+    debugLogging: false,
+};
+/**
+ * Durable cache inclusion policy that uses AuraStorage for persistent L2 cache
+ */
+class AuraDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
+    constructor(config = {}) {
+        super();
+        // Create storage with merged configuration
+        const storageConfig = {
+            ...DEFAULT_STORAGE_CONFIG,
+            ...config,
+        };
+        this.storage = createStorage(storageConfig);
+        if (!this.storage) {
+            console.warn('Failed to create durable storage for cache inclusion policy');
+        }
+    }
+    /**
+     * Revive cache entries from AuraStorage into L1 cache
+     * @param keys - Set of keys to revive
+     * @param l1 - L1 cache instance
+     * @returns Set of keys that were successfully revived
+     */
+    async revive(keys, l1) {
+        if (keys.size === 0 || !this.storage) {
+            return new Set();
+        }
+        const revivedKeys = new Set();
+        try {
+            // Convert keys to array of strings for getAll()
+            const keysArray = Array.from(keys).map((key) => key);
+            // Get only the requested entries using getAll() with specific keys
+            const storedData = (await this.storage.getAll(keysArray));
+            // Process the retrieved cache entries
+            for (const [storageKey, storedEntry] of Object.entries(storedData)) {
+                const key = storageKey;
+                const entry = storedEntry;
+                if (entry) {
+                    l1.set(key, entry);
+                    revivedKeys.add(key);
+                }
+            }
+        }
+        catch (error) {
+            // Log error but don't fail the operation
+            console.warn('Failed to revive cache entries from AuraStorage:', error);
+        }
+        return revivedKeys;
+    }
+    /**
+     * Sync changed keys from L1 cache to AuraStorage (L2 cache)
+     * @param changedKeys - Set of keys that have changed
+     * @param l1 - L1 cache instance
+     */
+    async syncToL2Cache(changedKeys, l1) {
+        if (changedKeys.size === 0 || !this.storage) {
+            return;
+        }
+        const promises = [];
+        for (const key of changedKeys) {
+            const storageKey = key;
+            const entry = l1.get(key);
+            if (entry) {
+                // Add or update the entry
+                promises.push(this.storage.set(storageKey, entry).catch((error) => {
+                    console.warn(`Failed to persist cache entry: ${storageKey}`, error);
+                }));
+            }
+            else {
+                // Remove the entry if it doesn't exist in L1
+                promises.push(this.storage
+                    .remove(storageKey)
+                    .catch((error) => {
+                    console.warn(`Failed to remove cache entry: ${storageKey}`, error);
+                })
+                    .then(() => { }));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Find entries matching a query
+     * @param query - Cache query to match entries
+     */
+    async *find(query) {
+        if (!this.storage) {
+            return;
+        }
+        try {
+            // Need to get all entries to search through them with the query
+            // Cannot pass specific keys since we don't know which entries match the query
+            const allStoredData = (await this.storage.getAll());
+            // Iterate through all cache entries and yield those matching the query
+            for (const [storageKey, storedEntry] of Object.entries(allStoredData)) {
+                const entry = storedEntry;
+                const key = storageKey;
+                if (entry && this.matchesQuery(key, entry, query)) {
+                    yield [key, entry];
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to find cache entries in AuraStorage:', error);
+        }
+    }
+    /**
+     * Find and modify entries matching a query
+     * @param query - Cache query to match entries
+     * @param cacheUpdate - Update to apply to matching entries
+     */
+    async *findAndModify(query, cacheUpdate) {
+        if (!this.storage) {
+            return;
+        }
+        try {
+            // Need to get all entries to search through them with the query
+            // Cannot pass specific keys since we don't know which entries match the query
+            const allStoredData = (await this.storage.getAll());
+            const modifiedEntries = [];
+            // Find and modify matching entries
+            for (const [storageKey, storedEntry] of Object.entries(allStoredData)) {
+                const entry = storedEntry;
+                const key = storageKey;
+                if (entry && this.matchesQuery(key, entry, query)) {
+                    // Apply the update to the entry
+                    const updatedEntry = this.applyUpdate(entry, cacheUpdate);
+                    if (updatedEntry) {
+                        modifiedEntries.push({ storageKey, entry: updatedEntry, modifiedKey: key });
+                    }
+                }
+            }
+            // Save all modified entries back to storage
+            if (modifiedEntries.length > 0 && this.storage) {
+                const promises = modifiedEntries.map(({ storageKey, entry }) => this.storage.set(storageKey, entry).catch((error) => {
+                    console.warn(`Failed to update cache entry: ${storageKey}`, error);
+                }));
+                await Promise.all(promises);
+                // Yield all modified keys
+                for (const { modifiedKey } of modifiedEntries) {
+                    yield modifiedKey;
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to find and modify cache entries in AuraStorage:', error);
+        }
+    }
+    /**
+     * Check if an entry matches a cache query
+     * @param key - Cache key to check
+     * @param entry - Cache entry to check
+     * @param query - Query to match against
+     * @returns true if the entry matches the query
+     */
+    matchesQuery(key, entry, query) {
+        if (!query)
+            return true;
+        // Handle logical operators
+        if (this.isAndQuery(query)) {
+            return query.$and.every((subQuery) => this.matchesQuery(key, entry, subQuery));
+        }
+        if (this.isOrQuery(query)) {
+            return query.$or.some((subQuery) => this.matchesQuery(key, entry, subQuery));
+        }
+        if (this.isNotQuery(query)) {
+            return !this.matchesQuery(key, entry, query.$not);
+        }
+        // Handle specific query types
+        if ('key' in query) {
+            return this.matchesKey(query.key, key);
+        }
+        if ('metadata' in query) {
+            return this.matchesMetadata(query.metadata, entry.metadata.cacheControl);
+        }
+        if ('value' in query) {
+            return false; // Value-based querying not implemented
+        }
+        return false; // Unknown query type
+    }
+    isAndQuery(query) {
+        return '$and' in query;
+    }
+    isOrQuery(query) {
+        return '$or' in query;
+    }
+    isNotQuery(query) {
+        return '$not' in query;
+    }
+    matchesKey(keyQuery, key) {
+        if ('$regex' in keyQuery) {
+            const keyString = typeof key === 'string' ? key : JSON.stringify(key);
+            return keyQuery.$regex.test(keyString);
+        }
+        return false;
+    }
+    matchesMetadata(metadataQuery, cacheControl) {
+        if ('cacheControlType' in metadataQuery &&
+            cacheControl.type !== metadataQuery.cacheControlType.$eq) {
+            return false;
+        }
+        if ('maxAge' in metadataQuery && cacheControl.type === 'max-age') {
+            const maxAge = cacheControl.maxAge ?? 0;
+            if ((metadataQuery.maxAge.$gte !== undefined && maxAge < metadataQuery.maxAge.$gte) ||
+                (metadataQuery.maxAge.$lte !== undefined && maxAge > metadataQuery.maxAge.$lte)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Apply an update to a cache entry
+     * @param entry - Original cache entry
+     * @param update - Update to apply
+     * @returns Updated entry or null if no update needed
+     */
+    applyUpdate(entry, update) {
+        try {
+            const updateResult = this.buildUpdate(update, entry);
+            switch (updateResult.type) {
+                case 'entry':
+                    return updateResult.entry;
+                case 'metadata':
+                    // Create a new entry with updated metadata
+                    return {
+                        ...entry,
+                        metadata: {
+                            ...entry.metadata,
+                            cacheControl: updateResult.metadata,
+                        },
+                    };
+                case 'no-op':
+                    return null; // No changes needed
+                default:
+                    return null;
+            }
+        }
+        catch (error) {
+            console.warn('Failed to apply update to cache entry:', error);
+            return null;
+        }
+    }
+    /**
+     * Build an update for a cache entry
+     * @param update - The cache update operation to apply
+     * @param existing - The existing cache entry being modified
+     * @returns An object indicating the type of update
+     */
+    buildUpdate(update, existing) {
+        switch (update.type) {
+            case 'invalidate':
+                const updatedCacheControl = this.buildInvalidatedCacheControl(existing.metadata.cacheControl);
+                return updatedCacheControl !== undefined
+                    ? { type: 'metadata', metadata: updatedCacheControl }
+                    : { type: 'no-op' };
+            default:
+                throw new Error(`Invalid update operation: ${update.type}`);
+        }
+    }
+    /**
+     * Build an invalidated cache control metadata
+     * @param existingCacheControl - The current CacheControlMetadata
+     * @returns A new CacheControlMetadata object with maxAge set to 0, or undefined if no changes needed
+     */
+    buildInvalidatedCacheControl(existingCacheControl) {
+        switch (existingCacheControl.type) {
+            case 'max-age':
+            case 'stale-while-revalidate':
+                if (existingCacheControl.maxAge !== 0) {
+                    return {
+                        ...existingCacheControl,
+                        maxAge: 0,
+                    };
+                }
+                return undefined; // Already invalidated
+            case 'no-cache':
+            case 'no-store':
+                // These types don't need invalidation
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+}
+/**
+ * Factory function to create an AuraDurableCacheInclusionPolicy service descriptor
+ * @param config - Optional configuration for the storage
+ * @returns Service descriptor for the cache inclusion policy
+ */
+function buildAuraDurableCacheInclusionPolicyService(config) {
+    return {
+        service: new AuraDurableCacheInclusionPolicy(config),
+        type: 'cacheInclusionPolicy',
+        version: '1.0',
+        tags: { storage: 'durable' },
+    };
+}
+
 // This code *should* be in lds-network-adapter, but when combined with the Aura
 // component test workaround in lds-default-luvio it creates a circular dependecy
 // between lds-default-luvio and lds-network-adapter. We do the register on behalf
@@ -7793,13 +9591,18 @@ function initializeLDS() {
 }
 // Initializes OneStore in LEX
 function initializeOneStore(luvio) {
-    const loggerService = new ConsoleLogger$1('ERROR');
-    const cacheServiceDescriptor = buildServiceDescriptor$9();
-    const instrumentationServiceDescriptor = buildServiceDescriptor$a(loggerService);
+    const loggerService = new ConsoleLogger('ERROR');
+    const cacheServiceDescriptor = buildServiceDescriptor$h();
+    const instrumentationServiceDescriptor = buildServiceDescriptor$i(loggerService);
     const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
-    const featureFlagsServiceDescriptor = buildServiceDescriptor$2();
+    const durableCacheInclusionPolicyServiceDescriptor = buildAuraDurableCacheInclusionPolicyService();
+    const durableCacheControlService = {
+        ...buildServiceDescriptor$g(cacheServiceDescriptor.service, durableCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
+        tags: { storage: 'durable' },
+    };
+    const featureFlagsServiceDescriptor = buildServiceDescriptor$a();
     const featureFlagsService = featureFlagsServiceDescriptor.service;
-    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$1((configs) => {
+    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$9((configs) => {
         return notifyUpdateAvailableFactory(luvio)(configs);
     }, (recordId, reader) => {
         const recordKey = buildRecordRepKeyFromId(recordId);
@@ -7818,8 +9621,11 @@ function initializeOneStore(luvio) {
         reader.unMarkMissing();
         return linkedData.data;
     });
-    const retryPolicy = new FetchThrottlingRetryPolicy();
-    const retryServiceDescriptor = buildServiceDescriptor(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 }));
@@ -7830,25 +9636,36 @@ function initializeOneStore(luvio) {
         buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
         buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
-        buildServiceDescriptor$b(instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$8(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$i(),
-        buildServiceDescriptor$6(),
+        buildServiceDescriptor$j(instrumentationServiceDescriptor.service),
+        // Ordering of services matters - L1 only CacheControlService must come before durable
+        buildServiceDescriptor$g(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
+        durableCacheControlService,
+        buildServiceDescriptor$q(),
         buildServiceDescriptor$e(),
-        buildServiceDescriptor$j(),
-        buildServiceDescriptor$d(),
-        buildServiceDescriptor$c(),
-        buildServiceDescriptor$h(),
-        buildServiceDescriptor$g(),
+        buildServiceDescriptor$m(),
+        buildServiceDescriptor$r(),
+        buildServiceDescriptor$l(),
+        buildServiceDescriptor$k(),
+        buildServiceDescriptor$p(),
+        buildServiceDescriptor$o(),
+        buildServiceDescriptor$n(),
         buildServiceDescriptor$f(),
-        buildServiceDescriptor$7(),
         buildLexRuntimeAllow5xxFetchServiceDescriptor(loggerService, retryService),
-        buildServiceDescriptor$5(luvio),
+        buildServiceDescriptor$d(luvio),
         luvioUiapiRecordsServiceDescriptor,
-        buildServiceDescriptor$4(),
-        buildServiceDescriptor$3(),
+        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);
 }
@@ -7868,4 +9685,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.400.0-8bade3324c
+// version: 1.402.0-bf9ae185ef