@salesforce/lds-runtime-aura 1.394.0 → 1.396.0

package/dist/ldsEngineCreator.js

@@ -340,7 +340,7 @@ let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 };
-function buildServiceDescriptor$j() {
+function buildServiceDescriptor$k() {
   return {
     type: "networkCommandBaseClass",
     version: "1.0",
@@ -442,7 +442,7 @@ class AuraNetworkCommand extends NetworkCommand$1 {
     return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
   }
 }
-function buildServiceDescriptor$i() {
+function buildServiceDescriptor$j() {
   return {
     type: "auraNetworkCommandBaseClass",
     version: "1.0",
@@ -614,6 +614,14 @@ class CacheControlRequestRunner {
   }
 }
 class CacheControlCommand extends BaseCommand {
+  /**
+   * Creates a new CacheControlCommand instance
+   *
+   * @param services - Required services including cache controller and optional pub/sub service
+   * @param services.cacheController - The cache controller service for managing cache operations
+   * @param services.pubSub - Optional pub/sub service for cache invalidation notifications
+   * @param services - Additional services specific to the implementation
+   */
   constructor(services) {
     super();
     this.services = services;
@@ -621,16 +629,31 @@ class CacheControlCommand extends BaseCommand {
     this.keysUpdated = void 0;
     this._isInternalExecution = false;
     this.lastResult = void 0;
-    this.unsubscribeFromKeysImpl = () => void 0;
+    this.unsubscribers = [];
     this.subscriptions = [];
     this.instantiationTime = Date.now() / 1e3;
   }
   get isInternalExecution() {
     return this._isInternalExecution;
   }
+  /**
+   * Executes the cache control command with optional overrides
+   *
+   * This method orchestrates the cache control flow by:
+   * 1. Clearing any existing subscriptions
+   * 2. Merging configuration overrides with the base strategy config
+   * 3. Building a request runner for cache operations
+   * 4. Executing the cache controller with the request runner
+   * 5. Handling the result and setting up subscriptions if needed
+   *
+   * @param overrides - Optional execution overrides including timestamp and cache control config
+   * @param overrides.now - Override the current timestamp for cache control calculations
+   * @param overrides.cacheControlConfig - Override cache control strategy configuration
+   * @returns A subscribable result containing either the cached/network data or an error
+   */
   execute(overrides) {
     this.keysUpdated = void 0;
-    this.unsubscribeFromKeys();
+    this.unsubscribe();
     const mergedCacheControlConfig = mergeCacheControlConfigs(
       this.cacheControlStrategyConfig,
       overrides
@@ -652,6 +675,17 @@ class CacheControlCommand extends BaseCommand {
       });
     });
   }
+  /**
+   * Handles the result from the cache controller and builds the appropriate subscribable result
+   *
+   * This method processes the cache controller execution result and determines the appropriate
+   * response based on network errors, cache errors, and available data. It handles graceful
+   * degradation scenarios where network data is available even when cache operations fail.
+   *
+   * @param result - The result from the cache controller execution
+   * @param requestRunner - The request runner containing network data and errors
+   * @returns A subscribable result with the appropriate data or error
+   */
   handleCacheControllerResult(result, requestRunner) {
     const { networkError, networkData, returnData } = requestRunner;
     return this.publishUpdatedKeys().then(() => {
@@ -687,11 +721,21 @@ class CacheControlCommand extends BaseCommand {
         );
       }
       if (this.subscriptions.length > 0) {
-        this.subscribeToKeysUsed();
+        this.subscribe();
       }
       return returnData;
     });
   }
+  /**
+   * Builds a request runner that orchestrates cache read, network request, and cache write operations
+   *
+   * The request runner encapsulates the three main operations:
+   * 1. Reading from cache with subscription setup
+   * 2. Requesting data from the network
+   * 3. Writing network results to cache and recording keys
+   *
+   * @returns A configured request runner for the cache controller
+   */
   buildRequestRunner() {
     return new CacheControlRequestRunner(
       (cache) => this.buildResultWithSubscribe(cache),
@@ -699,6 +743,15 @@ class CacheControlCommand extends BaseCommand {
       (cache, networkResult) => this.writeToCacheAndRecordKeys(cache, networkResult)
     );
   }
+  /**
+   * Publishes cache update events for keys that were modified during the operation
+   *
+   * This method notifies other parts of the system about cache changes by publishing
+   * a 'cacheUpdate' event with the set of keys that were updated. This enables
+   * cache invalidation and reactive updates across the application.
+   *
+   * @returns A promise that resolves when the update event is published (or immediately if no pub/sub service)
+   */
   publishUpdatedKeys() {
     if (this.services.pubSub) {
       if (this.keysUpdated !== void 0 && this.keysUpdated.size > 0) {
@@ -713,11 +766,25 @@ class CacheControlCommand extends BaseCommand {
   get operationType() {
     return "query";
   }
-  subscribeToKeysUsed() {
-    this.unsubscribeFromKeys();
+  /**
+   * Subscribes to cache update and invalidation events for reactive updates
+   *
+   * This method sets up subscriptions to listen for changes that affect the data returned
+   * by this Command.
+   *
+   * By default, it subscribes to two types of events on the PubSub service:
+   * - 'cacheUpdate': Triggers a rebuild with the original instantiation time
+   * - 'cacheInvalidation': Triggers a full refresh without time constraints
+   *
+   * This method can be extended by subclasses to add additional subscriptions.
+   *
+   * Note: ALL subscriptions should push an unsubscribe function to the unsubscribers array,
+   * for the lifecycle to work correctly and avoid memory leaks.
+   */
+  subscribe() {
+    this.unsubscribe();
     const { pubSub } = this.services;
     if (!pubSub) {
-      this.unsubscribeFromKeysImpl = () => void 0;
       return;
     }
     const rebuildUnsubscribe = pubSub.subscribe({
@@ -732,21 +799,58 @@ class CacheControlCommand extends BaseCommand {
       callback: () => this.rerun().then(() => void 0),
       keys: this.keysUsed
     });
-    this.unsubscribeFromKeysImpl = () => {
-      rebuildUnsubscribe();
-      refreshUnsubscribe();
-    };
-    return;
+    this.unsubscribers.push(rebuildUnsubscribe, refreshUnsubscribe);
   }
-  unsubscribeFromKeys() {
-    this.unsubscribeFromKeysImpl();
+  /**
+   * Unsubscribes from all stored subscriptions
+   *
+   * This method calls all stored unsubscribe functions to clean up event listeners
+   * and prevent memory leaks. It should be called when the command is no longer
+   * needed and is also called before setting up new subscriptions.
+   */
+  unsubscribe() {
+    while (this.unsubscribers.length > 0) {
+      const unsubscriber = this.unsubscribers.pop();
+      unsubscriber == null ? void 0 : unsubscriber();
+    }
   }
-  // TODO: This should likely be abstract in v2.  For v1, provide default comparison logic.
+  /**
+   * Compares two result values for equality to determine if a cache update should trigger a rerun
+   *
+   * This method is used to prevent unnecessary reruns when the cached data hasn't actually changed.
+   * The default implementation uses deep equality comparison, but subclasses can override this
+   * to provide more efficient or domain-specific comparison logic.
+   *
+   * @param result1 - The first result to compare
+   * @param result2 - The second result to compare
+   * @returns True if the results are equal, false otherwise
+   *
+   * @todo This should likely be abstract in v2. For v1, provide default comparison logic.
+   */
   equals(result1, result2) {
     return deepEquals$1(result1, result2);
   }
+  /**
+   * Hook method called after a network request completes
+   *
+   * This method provides a point for subclasses to perform post-request operations
+   * such as logging, metrics collection, or cleanup. The default implementation
+   * is empty and can be overridden by subclasses as needed.
+   *
+   * @param _options - Request completion options
+   * @param _options.statusCode - HTTP status code from the network response
+   */
   async afterRequestHooks(_options) {
   }
+  /**
+   * Forces a refresh of the cached data by bypassing cache and fetching from network
+   *
+   * This method executes the command with a "no-cache" configuration, ensuring that
+   * fresh data is fetched from the network regardless of cache state. It's useful
+   * for scenarios where you need to ensure the most up-to-date data.
+   *
+   * @returns A refresh result indicating success or failure of the refresh operation
+   */
   refresh() {
     return this.rerun({ cacheControlConfig: { type: "no-cache" } }).then((result) => {
       if (result.isErr()) {
@@ -755,6 +859,17 @@ class CacheControlCommand extends BaseCommand {
       return ok$1(void 0);
     });
   }
+  /**
+   * Writes network result to cache and records the keys that were updated
+   *
+   * This method wraps the cache write operation with key tracking functionality.
+   * It uses a recordable cache wrapper to capture which keys are modified during
+   * the write operation, then updates the internal tracking of used and updated keys.
+   *
+   * @param cache - The cache instance to write to
+   * @param networkResult - The network result containing data to write to cache
+   * @returns A result indicating success or failure of the write operation
+   */
   writeToCacheAndRecordKeys(cache, networkResult) {
     const recordableCache = cache.record();
     return this.writeToCache(recordableCache, networkResult).then((result) => {
@@ -763,6 +878,16 @@ class CacheControlCommand extends BaseCommand {
       return ok$1(result);
     });
   }
+  /**
+   * Builds a subscribable result by reading from cache and setting up subscriptions
+   *
+   * This method reads data from the cache and wraps the result in a subscribable
+   * structure that allows consumers to subscribe to updates. It also tracks which
+   * cache keys were read for future invalidation purposes.
+   *
+   * @param cache - The readonly cache to read from
+   * @returns A subscribable result containing the cached data or error
+   */
   buildResultWithSubscribe(cache) {
     const recordableCache = cache.record();
     const result = this.readFromCache(recordableCache);
@@ -790,23 +915,35 @@ class CacheControlCommand extends BaseCommand {
    * the last known value. If a change is detected, the provided
    * callback is invoked.
    *
-   * @param keysRead - keys of interest that were read during readFromCache
    * @returns an unsubscribe function to stop watching for updates
    */
   buildSubscribe() {
     return (consumerCallback) => {
       if (this.subscriptions.length === 0 && this.operationType === "query") {
-        this.subscribeToKeysUsed();
+        this.subscribe();
       }
       this.subscriptions.push(consumerCallback);
       return () => {
         this.subscriptions = this.subscriptions.filter((cb) => cb !== consumerCallback);
         if (this.subscriptions.length === 0) {
-          this.unsubscribeFromKeys();
+          this.unsubscribe();
         }
       };
     };
   }
+  /**
+   * Re-runs the command execution with optional overrides and notifies subscribers of changes
+   *
+   * This method is called internally when cache updates occur that affect the command's data.
+   * It executes the command with the provided overrides and compares the result with the
+   * last known result. If the data has changed, it notifies all subscribers with the new data.
+   *
+   * The method handles deduplication to prevent unnecessary notifications when the data
+   * hasn't actually changed, and properly manages the internal execution state.
+   *
+   * @param overrides - Optional execution overrides for the rerun
+   * @returns A promise that resolves to the execution result
+   */
   rerun(overrides) {
     this._isInternalExecution = true;
     return this.execute(overrides).then((result) => {
@@ -823,6 +960,15 @@ class CacheControlCommand extends BaseCommand {
       return result;
     });
   }
+  /**
+   * Invokes all registered consumer callbacks with the provided data
+   *
+   * This private method safely calls all registered subscriber callbacks with the
+   * provided result data. It includes error handling to prevent callback failures
+   * from affecting other callbacks or the overall system.
+   *
+   * @param data - The result data to send to all subscribers
+   */
   invokeConsumerCallbacks(data) {
     this.subscriptions.forEach((cb) => {
       try {
@@ -984,7 +1130,7 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand$1 {
     return `{"endpoint":${this.endpoint},"params":${stableJSONStringify$2(this.auraParams)}}`;
   }
 }
-function buildServiceDescriptor$h() {
+function buildServiceDescriptor$i() {
   return {
     type: "auraResourceCacheControlCommand",
     version: "1.0",
@@ -1123,7 +1269,7 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
     return resolvedPromiseLike$3(void 0);
   }
 }
-function buildServiceDescriptor$g() {
+function buildServiceDescriptor$h() {
   return {
     type: "auraNormalizedCacheControlCommand",
     version: "1.0",
@@ -1212,7 +1358,7 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
     return resolvedPromiseLike$3(void 0);
   }
 }
-function buildServiceDescriptor$f() {
+function buildServiceDescriptor$g() {
   return {
     type: "httpNormalizedCacheControlCommand",
     version: "1.0",
@@ -1390,7 +1536,7 @@ _FetchNetworkCommand.availableDecorators = {
   abortable: createAbortableDecorator
 };
 let FetchNetworkCommand = _FetchNetworkCommand;
-function buildServiceDescriptor$e() {
+function buildServiceDescriptor$f() {
   return {
     type: "fetchNetworkCommandBaseClass",
     version: "1.0",
@@ -1426,7 +1572,7 @@ class StreamingCommand extends BaseCommand {
     );
   }
 }
-function buildServiceDescriptor$d() {
+function buildServiceDescriptor$e() {
   return {
     type: "streamingCommandBaseClass",
     version: "1.0",
@@ -1509,7 +1655,7 @@ class SSEParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$c() {
+function buildServiceDescriptor$d() {
   return {
     type: "SSECommandBaseClass",
     version: "1.0",
@@ -1555,7 +1701,7 @@ function buildInstrumentCommand(services) {
     };
   };
 }
-function buildServiceDescriptor$b(instrumentation) {
+function buildServiceDescriptor$c(instrumentation) {
   return {
     type: "instrumentCommand",
     version: "1.0",
@@ -1825,7 +1971,7 @@ class O11yInstrumentation {
     this.metrics = new O11yOTelMetricsAPI(this.services);
   }
 }
-function buildServiceDescriptor$a(logger) {
+function buildServiceDescriptor$b(logger) {
   return {
     type: "instrumentation",
     version: "1.0",
@@ -2078,7 +2224,7 @@ class DefaultCache {
     return new FixedTimeWritableCache(this, generatedTime);
   }
 }
-function buildServiceDescriptor$9() {
+function buildServiceDescriptor$a() {
   return {
     type: "cache",
     version: "1.0",
@@ -2301,7 +2447,7 @@ class CacheController {
     yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
   }
 }
-function buildServiceDescriptor$8(cache, cacheInclusionPolicy, instrumentation) {
+function buildServiceDescriptor$9(cache, cacheInclusionPolicy, instrumentation) {
   return {
     type: "cacheController",
     version: "1.0",
@@ -2411,7 +2557,7 @@ class DefaultPubSubService {
     return matchingSubscriptions;
   }
 }
-function buildServiceDescriptor$7() {
+function buildServiceDescriptor$8() {
   return {
     type: "pubSub",
     version: "1.0",
@@ -2474,7 +2620,7 @@ class NDJSONParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$6() {
+function buildServiceDescriptor$7() {
   return {
     type: "NDJSONCommandBaseClass",
     version: "1.0",
@@ -2515,7 +2661,7 @@ function buildServiceDescriptor$6() {
  * };
  * ```
  */
-function buildServiceDescriptor$5(luvio) {
+function buildServiceDescriptor$6(luvio) {
     return {
         type: 'luvio',
         version: '1.0',
@@ -2524,7 +2670,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.394.0-db58817a4e
+// version: 1.396.0-216c6e4547
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -2682,13 +2828,13 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
         return this.runOriginalRequest();
       }
       if (this.subscriptions.length > 0) {
-        this.subscribeToKeysUsed();
+        this.subscribe();
       }
       return returnData;
     });
   }
 }
-function buildServiceDescriptor$4() {
+function buildServiceDescriptor$5() {
   return {
     type: "auraGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2800,13 +2946,13 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
         return this.runOriginalRequest();
       }
       if (this.subscriptions.length > 0) {
-        this.subscribeToKeysUsed();
+        this.subscribe();
       }
       return returnData;
     });
   }
 }
-function buildServiceDescriptor$3() {
+function buildServiceDescriptor$4() {
   return {
     type: "httpGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2830,7 +2976,7 @@ class FeatureFlagsService {
     return this.flags.get(flagName) || defaultValue;
   }
 }
-function buildServiceDescriptor$2() {
+function buildServiceDescriptor$3() {
   return {
     version: "1.0",
     service: new FeatureFlagsService(),
@@ -2852,7 +2998,7 @@ function buildServiceDescriptor$2() {
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
+function buildServiceDescriptor$2(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
     return {
         type: 'luvioUiapiRecords',
         version: '1.0',
@@ -2862,7 +3008,57 @@ function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.394.0-db58817a4e
+// version: 1.396.0-216c6e4547
+
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+class RetryService {
+  constructor(defaultRetryPolicy) {
+    this.defaultRetryPolicy = defaultRetryPolicy;
+  }
+  applyRetry(operation, retryPolicyOverride) {
+    return this.retry(operation, retryPolicyOverride || this.defaultRetryPolicy);
+  }
+  async retry(operation, policy) {
+    const startTime = Date.now();
+    let attempt = 0;
+    let result = await operation();
+    let context = {
+      attempt,
+      totalElapsedMs: Date.now() - startTime,
+      lastResult: result
+    };
+    while (policy.shouldRetry(result, context)) {
+      const delay = policy.calculateDelay(result, context);
+      await this.delay(delay);
+      attempt++;
+      result = await operation();
+      context = {
+        attempt,
+        totalElapsedMs: Date.now() - startTime,
+        lastResult: result
+      };
+    }
+    return result;
+  }
+  delay(ms) {
+    return new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
+  }
+}
+class RetryPolicy {
+}
+function buildServiceDescriptor$1(defaultRetryPolicy) {
+  return {
+    version: "1.0",
+    service: new RetryService(defaultRetryPolicy),
+    type: "retry"
+  };
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3203,7 +3399,7 @@ class JwtManager {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function buildServiceDescriptor(interceptors = { request: [], response: [] }) {
+function buildServiceDescriptor(interceptors = { request: [], response: [] }, retryService) {
   return {
     type: "fetch",
     version: "1.0",
@@ -3213,7 +3409,12 @@ function buildServiceDescriptor(interceptors = { request: [], response: [] }) {
         (previousPromise, interceptor) => previousPromise.then(interceptor),
         resolvedPromiseLike$3(args)
       );
-      return pending.then((args2) => fetch(...args2)).then((response) => {
+      return pending.then((args2) => {
+        if (retryService) {
+          return retryService.applyRetry(() => fetch(...args2));
+        }
+        return fetch(...args2);
+      }).then((response) => {
         return responseInterceptors.reduce(
           (previousPromise, interceptor) => previousPromise.then(interceptor),
           resolvedPromiseLike$3(response)
@@ -6364,7 +6565,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.394.0-db58817a4e
+// version: 1.396.0-216c6e4547
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -7066,29 +7267,96 @@ function buildInMemoryCacheInclusionPolicyService(cache) {
   };
 }
 
-function buildLexRuntimeDefaultFetchServiceDescriptor(logger) {
+function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
     const fetchService = buildServiceDescriptor({
         request: [],
         response: [
             buildLexRuntime5xxStatusResponseInterceptor(logger),
             buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
         ],
-    });
+    }, retryService);
     return {
         ...fetchService,
     };
 }
-function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger) {
+function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
     const fetchService = buildServiceDescriptor({
         request: [],
         response: [buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger)],
-    });
+    }, retryService);
     return {
         ...fetchService,
         tags: { interceptors: 'allow_500s' },
     };
 }
 
+const DEFAULT_CONFIG = {
+    maxRetries: 3,
+    maxTimeToRetry: 10000,
+    baseDelay: 250,
+    maxDelay: 5000,
+    exponentialFactor: 2,
+    jitterPercent: 0.5,
+};
+class Fetch429RetryPolicy extends RetryPolicy {
+    constructor(config = DEFAULT_CONFIG) {
+        super();
+        this.config = config;
+    }
+    shouldRetry(result, context) {
+        return (result.status === 429 &&
+            context.attempt < this.config.maxRetries &&
+            context.totalElapsedMs <= this.config.maxTimeToRetry);
+    }
+    calculateDelay(result, context) {
+        let delay;
+        // If retry-after header is present and valid, use it
+        const retryAfterHeader = this.parseRetryAfterHeader(result);
+        if (retryAfterHeader !== undefined) {
+            delay = Math.min(retryAfterHeader, this.config.maxDelay);
+        }
+        else {
+            // Exponential backoff
+            delay = Math.min(this.config.baseDelay * Math.pow(this.config.exponentialFactor, context.attempt), this.config.maxDelay);
+        }
+        // Add jitter to prevent thundering herd
+        const jitter = delay * this.config.jitterPercent * (Math.random() - 0.5);
+        return Math.max(0, delay + jitter);
+    }
+    parseRetryAfterHeader(result) {
+        if (!result.headers) {
+            return undefined;
+        }
+        const value = result.headers.get('Retry-After');
+        if (!value) {
+            return undefined;
+        }
+        // The Retry-After header can be either a number of seconds or an HTTP-date (IMF-fixdate)
+        // Retry-After: <delay-seconds>
+        // Retry-After: <http-date>
+        const trimmed = value.trim();
+        // Strictly treat only all-digits as seconds
+        if (/^\d+$/.test(trimmed)) {
+            const seconds = Number(trimmed);
+            if (Number.isFinite(seconds) && seconds >= 0) {
+                return seconds * 1000; // Convert to milliseconds
+            }
+            return undefined;
+        }
+        // Strict RFC 7231 IMF-fixdate format (e.g., "Sun, 06 Nov 1994 08:49:37 GMT")
+        const IMF_FIXDATE = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/;
+        if (!IMF_FIXDATE.test(trimmed)) {
+            return undefined;
+        }
+        // Use Date.parse to avoid any engine-specific fallbacks
+        const millis = Date.parse(trimmed);
+        if (Number.isFinite(millis)) {
+            return Math.max(0, millis - Date.now());
+        }
+        return undefined;
+    }
+}
+
 // 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
@@ -7350,12 +7618,12 @@ 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 cacheServiceDescriptor = buildServiceDescriptor$a();
+    const instrumentationServiceDescriptor = buildServiceDescriptor$b(loggerService);
     const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
-    const featureFlagsServiceDescriptor = buildServiceDescriptor$2();
+    const featureFlagsServiceDescriptor = buildServiceDescriptor$3();
     const featureFlagsService = featureFlagsServiceDescriptor.service;
-    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$1((configs) => {
+    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$2((configs) => {
         return notifyUpdateAvailableFactory(luvio)(configs);
     }, (recordId, reader) => {
         const recordKey = buildRecordRepKeyFromId(recordId);
@@ -7374,33 +7642,37 @@ function initializeOneStore(luvio) {
         reader.unMarkMissing();
         return linkedData.data;
     });
+    const retryPolicy = new Fetch429RetryPolicy();
+    const retryServiceDescriptor = buildServiceDescriptor$1(retryPolicy);
+    const retryService = retryServiceDescriptor.service;
     // set flags based on gates
     featureFlagsService.set('useOneStoreGraphQL', useOneStoreGraphql.isOpen({ fallback: false }));
     const services = [
         instrumentationServiceDescriptor,
+        buildLexRuntimeDefaultFetchServiceDescriptor(loggerService, retryService),
         buildUnauthorizedFetchServiceDescriptor(),
         buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
         buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
-        buildServiceDescriptor$b(instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$8(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$i(),
-        buildServiceDescriptor$6(),
-        buildServiceDescriptor$e(),
+        buildServiceDescriptor$c(instrumentationServiceDescriptor.service),
+        buildServiceDescriptor$9(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
         buildServiceDescriptor$j(),
+        buildServiceDescriptor$7(),
+        buildServiceDescriptor$f(),
+        buildServiceDescriptor$k(),
+        buildServiceDescriptor$e(),
         buildServiceDescriptor$d(),
-        buildServiceDescriptor$c(),
+        buildServiceDescriptor$i(),
         buildServiceDescriptor$h(),
         buildServiceDescriptor$g(),
-        buildServiceDescriptor$f(),
-        buildServiceDescriptor$7(),
-        buildLexRuntimeDefaultFetchServiceDescriptor(loggerService),
-        buildLexRuntimeAllow5xxFetchServiceDescriptor(loggerService),
-        buildServiceDescriptor$5(luvio),
+        buildServiceDescriptor$8(),
+        buildLexRuntimeAllow5xxFetchServiceDescriptor(loggerService, retryService),
+        buildServiceDescriptor$6(luvio),
         luvioUiapiRecordsServiceDescriptor,
+        buildServiceDescriptor$5(),
         buildServiceDescriptor$4(),
-        buildServiceDescriptor$3(),
         featureFlagsServiceDescriptor,
+        retryServiceDescriptor,
     ];
     setServices(services);
 }
@@ -7420,4 +7692,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.394.0-9f5a21c62e
+// version: 1.396.0-08650966f4

package/dist/types/fetch-service-descriptors/lex-fetch-service.d.ts

@@ -1,4 +1,5 @@
 import { type LoggerService } from '@luvio/utils';
 import { type FetchServiceDescriptor } from '@luvio/service-fetch-network/v1';
-export declare function buildLexRuntimeDefaultFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
-export declare function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger: LoggerService): FetchServiceDescriptor;
+import { RetryService } from '@luvio/service-retry/v1';
+export declare function buildLexRuntimeDefaultFetchServiceDescriptor(logger: LoggerService, retryService?: RetryService<Response>): FetchServiceDescriptor;
+export declare function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger: LoggerService, retryService?: RetryService<Response>): FetchServiceDescriptor;

package/dist/types/retry-policies/fetch-429-retry-policy.d.ts

@@ -0,0 +1,17 @@
+import { RetryPolicy, RetryContext } from '@luvio/service-retry/v1';
+type Fetch429RetryPolicyConfig = {
+    maxRetries: number;
+    maxTimeToRetry: number;
+    baseDelay: number;
+    maxDelay: number;
+    exponentialFactor: number;
+    jitterPercent: number;
+};
+export declare class Fetch429RetryPolicy extends RetryPolicy<Response> {
+    private config;
+    constructor(config?: Fetch429RetryPolicyConfig);
+    shouldRetry(result: Response, context: RetryContext<Response>): boolean;
+    calculateDelay(result: Response, context: RetryContext<Response>): number;
+    parseRetryAfterHeader(result: Response): number | undefined;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.394.0",
+    "version": "1.396.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,47 +34,47 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-provisioner": "5.64.2",
-        "@luvio/tools-core": "5.64.2",
-        "@salesforce/lds-adapters-apex": "^1.394.0",
-        "@salesforce/lds-adapters-uiapi": "^1.394.0",
-        "@salesforce/lds-ads-bridge": "^1.394.0",
-        "@salesforce/lds-aura-storage": "^1.394.0",
-        "@salesforce/lds-bindings": "^1.394.0",
-        "@salesforce/lds-instrumentation": "^1.394.0",
-        "@salesforce/lds-network-aura": "^1.394.0",
-        "@salesforce/lds-network-fetch": "^1.394.0",
+        "@luvio/service-provisioner": "5.65.1",
+        "@luvio/tools-core": "5.65.1",
+        "@salesforce/lds-adapters-apex": "^1.396.0",
+        "@salesforce/lds-adapters-uiapi": "^1.396.0",
+        "@salesforce/lds-ads-bridge": "^1.396.0",
+        "@salesforce/lds-aura-storage": "^1.396.0",
+        "@salesforce/lds-bindings": "^1.396.0",
+        "@salesforce/lds-instrumentation": "^1.396.0",
+        "@salesforce/lds-network-aura": "^1.396.0",
+        "@salesforce/lds-network-fetch": "^1.396.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@luvio/command-aura-graphql-normalized-cache-control": "5.64.2",
-        "@luvio/command-aura-network": "5.64.2",
-        "@luvio/command-aura-normalized-cache-control": "5.64.2",
-        "@luvio/command-aura-resource-cache-control": "5.64.2",
-        "@luvio/command-fetch-network": "5.64.2",
-        "@luvio/command-http-graphql-normalized-cache-control": "5.64.2",
-        "@luvio/command-http-normalized-cache-control": "5.64.2",
-        "@luvio/command-ndjson": "5.64.2",
-        "@luvio/command-network": "5.64.2",
-        "@luvio/command-sse": "5.64.2",
-        "@luvio/command-streaming": "5.64.2",
+        "@luvio/command-aura-graphql-normalized-cache-control": "5.65.1",
+        "@luvio/command-aura-network": "5.65.1",
+        "@luvio/command-aura-normalized-cache-control": "5.65.1",
+        "@luvio/command-aura-resource-cache-control": "5.65.1",
+        "@luvio/command-fetch-network": "5.65.1",
+        "@luvio/command-http-graphql-normalized-cache-control": "5.65.1",
+        "@luvio/command-http-normalized-cache-control": "5.65.1",
+        "@luvio/command-ndjson": "5.65.1",
+        "@luvio/command-network": "5.65.1",
+        "@luvio/command-sse": "5.65.1",
+        "@luvio/command-streaming": "5.65.1",
         "@luvio/network-adapter-composable": "0.158.7",
         "@luvio/network-adapter-fetch": "0.158.7",
-        "@luvio/service-aura-network": "5.64.2",
-        "@luvio/service-cache": "5.64.2",
-        "@luvio/service-cache-control": "5.64.2",
-        "@luvio/service-cache-inclusion-policy": "5.64.2",
-        "@luvio/service-feature-flags": "5.64.2",
-        "@luvio/service-fetch-network": "5.64.2",
-        "@luvio/service-instrument-command": "5.64.2",
-        "@luvio/service-pubsub": "5.64.2",
-        "@luvio/service-store": "5.64.2",
-        "@luvio/utils": "5.64.2",
+        "@luvio/service-aura-network": "5.65.1",
+        "@luvio/service-cache": "5.65.1",
+        "@luvio/service-cache-control": "5.65.1",
+        "@luvio/service-cache-inclusion-policy": "5.65.1",
+        "@luvio/service-feature-flags": "5.65.1",
+        "@luvio/service-fetch-network": "5.65.1",
+        "@luvio/service-instrument-command": "5.65.1",
+        "@luvio/service-pubsub": "5.65.1",
+        "@luvio/service-store": "5.65.1",
+        "@luvio/utils": "5.65.1",
         "@lwc/state": "^0.23.0",
-        "@salesforce/lds-adapters-onestore-graphql": "^1.394.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.394.0",
-        "@salesforce/lds-luvio-service": "^1.394.0",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.394.0"
+        "@salesforce/lds-adapters-onestore-graphql": "^1.396.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.396.0",
+        "@salesforce/lds-luvio-service": "^1.396.0",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.396.0"
     },
     "luvioBundlesize": [
         {