@salesforce/lds-runtime-aura 1.410.0 → 1.411.0

package/dist/ldsEngineCreator.js

@@ -18,7 +18,6 @@ import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
 import useApexPredictions from '@salesforce/gate/lds.pdl.useApexPredictions';
 import useRelatedListsPredictions from '@salesforce/gate/lds.pdl.useRelatedListsPredictions';
 import useRelatedListPlus from '@salesforce/gate/lds.pdl.useRelatedListPlus';
-import useCmpDefPredictions from '@salesforce/gate/lds.pdl.useCmpDefPredictions';
 import applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
 import useLocalStorage from '@salesforce/gate/lds.pdl.useLocalStorage';
 import useOneStoreGraphql from '@salesforce/gate/lds.oneStoreGraphqlEnabled.ltng';
@@ -476,7 +475,12 @@ class AuraNetworkCommand extends NetworkCommand$1 {
         this.coerceAuraErrors
       );
     } else if (this.shouldUseFetch()) {
-      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+      const params = this.fetchParams;
+      try {
+        return this.convertFetchResponseToData(this.services.fetch(...params));
+      } catch (reason) {
+        return resolvedPromiseLike$2(err$1(toError(reason)));
+      }
     }
     return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
@@ -1074,7 +1078,12 @@ let AuraCacheControlCommand$1 = class AuraCacheControlCommand extends CacheContr
         (errs) => this.coerceAuraErrors(errs)
       );
     } else if (this.shouldUseFetch()) {
-      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+      const params = this.fetchParams;
+      try {
+        return this.convertFetchResponseToData(this.services.fetch(...params));
+      } catch (reason) {
+        return resolvedPromiseLike$2(err$1(toError(reason)));
+      }
     }
     return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
@@ -1217,7 +1226,12 @@ class AuraCacheControlCommand extends CacheControlCommand {
         (errs) => this.coerceAuraErrors(errs)
       );
     } else if (this.shouldUseFetch()) {
-      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+      const params = this.fetchParams;
+      try {
+        return this.convertFetchResponseToData(this.services.fetch(...params));
+      } catch (reason) {
+        return resolvedPromiseLike$2(err$1(toError(reason)));
+      }
     }
     return resolvedPromiseLike$2(err$1(toError("Aura/Fetch network services not found")));
   }
@@ -1335,7 +1349,11 @@ class HttpCacheControlCommand extends CacheControlCommand {
     return this.fetch();
   }
   fetch() {
-    return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    try {
+      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    } catch (reason) {
+      return resolvedPromiseLike$2(err$1(toError(reason)));
+    }
   }
   async coerceError(errorResponse) {
     return toError(errorResponse.statusText);
@@ -1538,7 +1556,11 @@ const _FetchNetworkCommand = class _FetchNetworkCommand extends NetworkCommand {
     this.services = services;
   }
   fetch() {
-    return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    try {
+      return this.convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    } catch (reason) {
+      return resolvedPromiseLike$2(err$1(toError(reason)));
+    }
   }
   async coerceError(errorResponse) {
     return toError(errorResponse.statusText);
@@ -1594,7 +1616,11 @@ class StreamingCommand extends BaseCommand {
     this.services = services;
   }
   execute() {
-    return this.convertFetchStreamResponseToData(this.services.fetch(...this.fetchParams));
+    try {
+      return this.convertFetchStreamResponseToData(this.services.fetch(...this.fetchParams));
+    } catch (reason) {
+      return resolvedPromiseLike$2(err$1(toError(reason)));
+    }
   }
   convertFetchStreamResponseToData(response) {
     return response.then(
@@ -2430,9 +2456,13 @@ class OnlyIfCachedCacheControlStrategy extends CacheControlStrategy {
   }
   get expiredChecks() {
     return [
-      (cacheControlMetadata) => cacheControlMetadata.type === "no-store"
+      ...super.expiredChecks,
+      (cacheControlMetadata) => cacheControlMetadata.type === "no-cache"
     ];
   }
+  // Note: If we add support for `stale-while-revalidate` in the future, we may
+  // need to further override expiredChecks to allow stale entries that are within the
+  // stale-while-revalidate window to be returned for only-if-cached requests.
   collectCacheHitInstrumentation(startTime, instrumentationAttributes) {
     if (this.services.instrumentation) {
       const meter = this.services.instrumentation.metrics.getMeter("onestore");
@@ -2672,7 +2702,7 @@ function buildServiceDescriptor$d(luvio) {
         },
     };
 }
-// version: 1.410.0-7c228ee347
+// version: 1.411.0-8fa163ef05
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -2788,11 +2818,26 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
         return buildSubscribableResult$1(result, this.buildSubscribe(), () => this.refresh());
       });
     } else if (this.shouldUseFetch()) {
-      return this.convertFetchResponseToData(
-        this.services.fetch(...this.originalFetchParams)
-      ).then((result) => {
-        return buildSubscribableResult$1(result, this.buildSubscribe(), () => this.refresh());
-      });
+      const params = this.originalFetchParams;
+      try {
+        return this.convertFetchResponseToData(this.services.fetch(...params)).then(
+          (result) => {
+            return buildSubscribableResult$1(
+              result,
+              this.buildSubscribe(),
+              () => this.refresh()
+            );
+          }
+        );
+      } catch (reason) {
+        return resolvedPromiseLike$2(
+          buildSubscribableResult$1(
+            err$1(toError(reason)),
+            this.buildSubscribe(),
+            () => this.refresh()
+          )
+        );
+      }
     }
     return resolvedPromiseLike$2(
       buildSubscribableResult$1(
@@ -3010,7 +3055,7 @@ function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.410.0-7c228ee347
+// version: 1.411.0-8fa163ef05
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3561,7 +3606,7 @@ class GraphQLLegacyImperativeBindingsService {
     return { invoke, subscribe };
   }
 }
-function buildServiceDescriptor$1$1() {
+function buildServiceDescriptor$1$2() {
   return {
     type: "graphQLLegacyImperativeBindings",
     version: "1.0",
@@ -3838,7 +3883,7 @@ class LWCWireBindingsService {
     };
   }
 }
-function buildServiceDescriptor$1() {
+function buildServiceDescriptor$1$1() {
   return {
     type: "lwcWireBindings",
     version: "1.0",
@@ -3951,7 +3996,7 @@ function createLockerCompatibleWireConstructor(DelegateCtor) {
     return Constructor;
 }
 function buildLWCWireBindingsServiceDescriptor() {
-    const base = buildServiceDescriptor$1();
+    const base = buildServiceDescriptor$1$1();
     const originalBind = base.service.bind.bind(base.service);
     const bind = (...args) => {
         const ctor = originalBind(...args);
@@ -4276,6 +4321,53 @@ class JwtManager {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
+function buildServiceDescriptor$1(interceptors = {
+  request: [],
+  retry: void 0,
+  response: [],
+  finally: []
+}, retryService) {
+  return {
+    type: "fetch",
+    version: "1.0",
+    service: function(...args) {
+      var _a;
+      const context = (_a = interceptors.createContext) == null ? void 0 : _a.call(interceptors);
+      const {
+        request: requestInterceptors = [],
+        retry: retryInterceptor = void 0,
+        response: responseInterceptors = [],
+        finally: finallyInterceptors = []
+      } = interceptors;
+      const pending = requestInterceptors.reduce(
+        (previousPromise, interceptor) => previousPromise.then((args2) => interceptor(args2, context)),
+        resolvedPromiseLike$2(args)
+      );
+      return Promise.resolve(pending).then((args2) => {
+        if (retryInterceptor) {
+          return retryInterceptor(args2, retryService, context);
+        } else {
+          if (retryService) {
+            return retryService.applyRetry(() => fetch(...args2));
+          }
+          return fetch(...args2);
+        }
+      }).then((response) => {
+        return responseInterceptors.reduce(
+          (previousPromise, interceptor) => previousPromise.then((response2) => interceptor(response2, context)),
+          resolvedPromiseLike$2(response)
+        );
+      }).finally(() => {
+        if (finallyInterceptors.length > 0) {
+          return finallyInterceptors.reduce(
+            (previousPromise, interceptor) => previousPromise.then(() => interceptor(context)),
+            Promise.resolve()
+          );
+        }
+      });
+    }
+  };
+}
 function setHeader(headerName, headerValue, [resource, options = {}], {
   throwOnExisting = false,
   errorMessage = `Unexpected ${headerName} header encountered`
@@ -4713,7 +4805,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.410.0-7c228ee347
+// version: 1.411.0-8fa163ef05
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -6109,41 +6201,6 @@ function createStartMark(requestId) {
     };
 }
 
-function buildPageScopedCacheRequestInterceptor() {
-    return async (fetchArgs) => {
-        const pageScopedCacheHeaders = {};
-        // Allow the instrumentation util to set up the header value on our "dummy" header object
-        pageScopedCache.addHeader(pageScopedCacheHeaders);
-        let returnedFetchArgs = fetchArgs;
-        // If it set a value, add it to our fetchParams
-        Object.entries(pageScopedCacheHeaders).forEach(([key, value]) => {
-            returnedFetchArgs = setHeader(key, value, returnedFetchArgs);
-        });
-        return resolvedPromiseLike$2(returnedFetchArgs);
-    };
-}
-
-const SFDC_REQUEST_ID_KEY = 'X-SFDC-Request-Id';
-function buildTransportMarksSendInterceptor() {
-    return async (fetchArgs, context) => {
-        // First set the requestId header. If there's not context, it means we won't be able to track the mark and something is hosed, and so not worth even trying
-        if (context && context.instrumentationId) {
-            const requestId = context.instrumentationId;
-            fetchArgs = setHeader(SFDC_REQUEST_ID_KEY, requestId, fetchArgs);
-            createStartMark(requestId);
-        }
-        return resolvedPromiseLike$2(fetchArgs);
-    };
-}
-
-function buildTransportMarksReceiveInterceptor() {
-    return async (context) => {
-        if (context && context.instrumentationId) {
-            markEnd('transport', 'request', { auraXHRId: context.instrumentationId });
-        }
-    };
-}
-
 const DEFAULT_CONFIG$1 = {
     maxRetries: 1, // Only retry once after token refresh
 };
@@ -6245,95 +6302,30 @@ async function isCsrfError(response) {
     }
 }
 
-function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
-    const fetchService = buildLexConnectFetchServiceDescriptor({
-        createContext: createInstrumentationIdContext(),
-        request: [
-            buildThirdPartyTrackerRegisterInterceptor(),
-            buildPageScopedCacheRequestInterceptor(),
-            buildTransportMarksSendInterceptor(),
-            buildCsrfTokenInterceptor(),
-        ],
-        response: [
-            buildLexRuntime5xxStatusResponseInterceptor(logger),
-            buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
-        ],
-        finally: [
-            buildTransportMarksReceiveInterceptor(),
-            buildThirdPartyTrackerFinishInterceptor(),
-        ],
-    }, retryService);
-    return {
-        ...fetchService,
-    };
-}
-function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
-    const fetchService = buildLexConnectFetchServiceDescriptor({
-        createContext: createInstrumentationIdContext(),
-        request: [
-            buildThirdPartyTrackerRegisterInterceptor(),
-            buildPageScopedCacheRequestInterceptor(),
-            buildTransportMarksSendInterceptor(),
-            buildCsrfTokenInterceptor(),
-        ],
-        response: [buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger)],
-        finally: [
-            buildTransportMarksReceiveInterceptor(),
-            buildThirdPartyTrackerFinishInterceptor(),
-        ],
-    }, retryService);
-    return {
-        ...fetchService,
-        tags: { interceptors: 'allow_500s' },
-    };
-}
-// Temporarily cloned from conduit fetch until the retry service is updated there
-function buildLexConnectFetchServiceDescriptor(interceptors = { request: [], response: [], finally: [] }, retryService) {
-    return {
-        type: 'fetch',
-        version: '1.0',
-        service: function (...args) {
-            // Create context per request if factory is provided
-            const context = interceptors.createContext?.();
-            const { request: requestInterceptors = [], response: responseInterceptors = [], finally: finallyInterceptors = [], } = interceptors;
-            const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((args) => interceptor(args, context)), resolvedPromiseLike$2(args));
-            return Promise.resolve(pending)
-                .then((interceptedArgs) => {
-                if (retryService) {
-                    // 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(...interceptedArgs);
-            })
-                .then((response) => {
-                // Success path - run response interceptors
-                return responseInterceptors.reduce((previousPromise, interceptor) => previousPromise.then((response) => interceptor(response, context)), resolvedPromiseLike$2(response));
-            })
-                .finally(() => {
-                // Always run finally interceptors for cleanup
-                if (finallyInterceptors.length > 0) {
-                    // Run all finally interceptors sequentially
-                    return finallyInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(() => interceptor(context)), Promise.resolve());
+function buildCsrfRetryInterceptor() {
+    return async (fetchArgs, retryService, context) => {
+        if (retryService) {
+            // Create mutable context for CSRF retry policy
+            const mutableRequest = { args: fetchArgs };
+            // 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(...fetchArgs);
     };
 }
 
@@ -6341,9 +6333,10 @@ const SFAP_BASE_URL = 'api.salesforce.com';
 const sfapJwtRepository = new JwtRepository();
 const sfapJwtManager = new JwtManager(sfapJwtRepository, platformSfapJwtResolver);
 function buildJwtAuthorizedSfapFetchServiceDescriptor(logger) {
-    const jwtAuthorizedFetchService = buildLexConnectFetchServiceDescriptor({
+    const jwtAuthorizedFetchService = buildServiceDescriptor$1({
         createContext: createInstrumentationIdContext(),
         request: [buildThirdPartyTrackerRegisterInterceptor(), buildJwtRequestInterceptor(logger)],
+        retry: buildCsrfRetryInterceptor(),
         finally: [buildThirdPartyTrackerFinishInterceptor()],
     });
     return {
@@ -6362,7 +6355,7 @@ function buildCopilotFetchServiceDescriptor(logger) {
         // we switch to JWT authentication this will need to change to incorporate the
         // Interceptor here with the logic in buildJwtAuthorizedSfapFetchServiceDescriptor()
         // above.
-        ...buildLexConnectFetchServiceDescriptor({
+        ...buildServiceDescriptor$1({
             createContext: createInstrumentationIdContext(),
             request: [
                 buildThirdPartyTrackerRegisterInterceptor(),
@@ -6405,15 +6398,17 @@ function buildCopilotFetchServiceDescriptor(logger) {
                 },
                 buildJwtRequestInterceptor(logger),
             ],
+            retry: buildCsrfRetryInterceptor(),
             finally: [buildThirdPartyTrackerFinishInterceptor()],
         }),
         tags: { specialHacksFor: 'copilot' },
     };
 }
 function buildUnauthorizedFetchServiceDescriptor() {
-    const fetchService = buildLexConnectFetchServiceDescriptor({
+    const fetchService = buildServiceDescriptor$1({
         createContext: createInstrumentationIdContext(),
         request: [buildThirdPartyTrackerRegisterInterceptor()],
+        retry: buildCsrfRetryInterceptor(),
         finally: [buildThirdPartyTrackerFinishInterceptor()],
     });
     return {
@@ -8131,10 +8126,45 @@ class ObjectHomePage extends AbstractHomePage {
     }
 }
 
+var PdlPrefetcherEventType;
+(function (PdlPrefetcherEventType) {
+    PdlPrefetcherEventType["STARTED_RECORDING"] = "started-recording";
+    PdlPrefetcherEventType["STOPPED_RECORDING"] = "stopped-recording";
+})(PdlPrefetcherEventType || (PdlPrefetcherEventType = {}));
+class PrefetcherEventEmitter {
+    constructor() {
+        this.listeners = new Map();
+    }
+    subscribeTo(type, listener) {
+        const typeListeners = this.listeners.get(type) ?? [];
+        typeListeners.push(listener);
+        this.listeners.set(type, typeListeners);
+        return () => {
+            const currentListeners = this.listeners.get(type) ?? [];
+            this.listeners.set(type, currentListeners.filter((l) => l !== listener));
+        };
+    }
+    emit(event) {
+        const typeListeners = this.listeners.get(event.type) ?? [];
+        typeListeners.forEach((listener) => {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                // swallow errors in production.
+                if (process.env.NODE_ENV !== 'production') {
+                    throw error;
+                }
+            }
+        });
+    }
+}
+
 class ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner) {
+    constructor(context, repository, requestRunner, eventEmitter) {
         this.repository = repository;
         this.requestRunner = requestRunner;
+        this.eventEmitter = eventEmitter;
         this.isRecording = false;
         this.totalRequestCount = 0;
         this.queuedPredictionRequests = [];
@@ -8148,15 +8178,26 @@ class ApplicationPredictivePrefetcher {
     get context() {
         return this._context;
     }
+    subscribeToEvent(type, callback) {
+        return this.eventEmitter.subscribeTo(type, callback);
+    }
     async stopRecording() {
         this.isRecording = false;
         this.totalRequestCount = 0;
         await this.repository.flushRequestsToStorage();
+        this.eventEmitter.emit({
+            type: PdlPrefetcherEventType.STOPPED_RECORDING,
+            page: this.page,
+        });
     }
     startRecording() {
         this.isRecording = true;
         this.repository.markPageStart();
         this.repository.clearRequestBuffer();
+        this.eventEmitter.emit({
+            type: PdlPrefetcherEventType.STARTED_RECORDING,
+            page: this.page,
+        });
     }
     saveRequest(request) {
         if (!this.isRecording) {
@@ -8339,11 +8380,11 @@ function predictNonBoxcarableRequest(nonBoxcaredPredictions, requestRunner) {
 const DEFAULT_RECORD_TYPE_ID = '012000000000000AAA';
 const AURA_BOXCAR_THREADS_THRESHOLD = 3;
 class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner, 
+    constructor(context, repository, requestRunner, eventEmitter, 
     // These strategies need to be in sync with the "predictiveDataLoadCapable" list
     // from scripts/lds-uiapi-plugin.js
     requestStrategyManager, options) {
-        super(context, repository, requestRunner);
+        super(context, repository, requestRunner, eventEmitter);
         this.options = options;
         this.requestStrategyManager = requestStrategyManager;
         this.page = this.getPage();
@@ -9193,6 +9234,86 @@ function buildInMemoryCacheInclusionPolicyService(cache) {
   };
 }
 
+function buildPageScopedCacheRequestInterceptor() {
+    return async (fetchArgs) => {
+        const pageScopedCacheHeaders = {};
+        // Allow the instrumentation util to set up the header value on our "dummy" header object
+        pageScopedCache.addHeader(pageScopedCacheHeaders);
+        let returnedFetchArgs = fetchArgs;
+        // If it set a value, add it to our fetchParams
+        Object.entries(pageScopedCacheHeaders).forEach(([key, value]) => {
+            returnedFetchArgs = setHeader(key, value, returnedFetchArgs);
+        });
+        return resolvedPromiseLike$2(returnedFetchArgs);
+    };
+}
+
+const SFDC_REQUEST_ID_KEY = 'X-SFDC-Request-Id';
+function buildTransportMarksSendInterceptor() {
+    return async (fetchArgs, context) => {
+        // First set the requestId header. If there's not context, it means we won't be able to track the mark and something is hosed, and so not worth even trying
+        if (context && context.instrumentationId) {
+            const requestId = context.instrumentationId;
+            fetchArgs = setHeader(SFDC_REQUEST_ID_KEY, requestId, fetchArgs);
+            createStartMark(requestId);
+        }
+        return resolvedPromiseLike$2(fetchArgs);
+    };
+}
+
+function buildTransportMarksReceiveInterceptor() {
+    return async (context) => {
+        if (context && context.instrumentationId) {
+            markEnd('transport', 'request', { auraXHRId: context.instrumentationId });
+        }
+    };
+}
+
+function buildLexRuntimeDefaultFetchServiceDescriptor(logger, retryService) {
+    const fetchService = buildServiceDescriptor$1({
+        createContext: createInstrumentationIdContext(),
+        request: [
+            buildThirdPartyTrackerRegisterInterceptor(),
+            buildPageScopedCacheRequestInterceptor(),
+            buildTransportMarksSendInterceptor(),
+            buildCsrfTokenInterceptor(),
+        ],
+        retry: buildCsrfRetryInterceptor(),
+        response: [
+            buildLexRuntime5xxStatusResponseInterceptor(logger),
+            buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger),
+        ],
+        finally: [
+            buildTransportMarksReceiveInterceptor(),
+            buildThirdPartyTrackerFinishInterceptor(),
+        ],
+    }, retryService);
+    return {
+        ...fetchService,
+    };
+}
+function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger, retryService) {
+    const fetchService = buildServiceDescriptor$1({
+        createContext: createInstrumentationIdContext(),
+        request: [
+            buildThirdPartyTrackerRegisterInterceptor(),
+            buildPageScopedCacheRequestInterceptor(),
+            buildTransportMarksSendInterceptor(),
+            buildCsrfTokenInterceptor(),
+        ],
+        retry: buildCsrfRetryInterceptor(),
+        response: [buildLexRuntimeAuthExpirationRedirectResponseInterceptor(logger)],
+        finally: [
+            buildTransportMarksReceiveInterceptor(),
+            buildThirdPartyTrackerFinishInterceptor(),
+        ],
+    }, retryService);
+    return {
+        ...fetchService,
+        tags: { interceptors: 'allow_500s' },
+    };
+}
+
 const DEFAULT_CONFIG = {
     maxRetries: 3,
     maxTimeToRetry: 10000,
@@ -9668,43 +9789,31 @@ function setupPredictivePrefetcher(luvio) {
     const prefetcherOptions = {
         inflightRequestLimit,
     };
-    const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, requestStrategyManager, prefetcherOptions);
+    const eventEmitter = new PrefetcherEventEmitter();
+    const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, eventEmitter, requestStrategyManager, prefetcherOptions);
     registerPrefetcher(luvio, prefetcher);
     if (useApexPredictions.isOpen({ fallback: false })) {
         registerPrefetcher$1(luvio, prefetcher);
     }
     __lexPrefetcher = prefetcher;
 }
-function loadComponentsDefStartedOverride(...args) {
-    /**
-     * To install an override (taken from the Aura.Utils.Override):
-     *
-     * The function supplied should have the following code in it:
-     * ------
-     *  var config = Array.prototype.shift.apply(arguments);
-     *  var ret = config["fn"].apply(config["scope"], arguments);
-     *  return ret
-     * ------
-     */
-    const config = Array.prototype.shift.apply(args);
-    const ret = config['fn'].apply(config['scope'], args);
-    try {
-        const defs = args[0] || {};
-        __lexPrefetcher.saveRequest({
-            adapterName: 'getComponentsDef',
-            config: defs,
-        });
-    }
-    catch (e) {
-        // dismiss any error, the activity will log it.
-    }
-    return ret;
-}
 function saveRequestAsPrediction(request) {
     if (__lexPrefetcher !== undefined) {
         __lexPrefetcher.saveRequest(request);
     }
 }
+/**
+ * Subscribes to a specific prefetcher event type.
+ * @param type - The type of event to subscribe to.
+ * @param callback - The callback to invoke when the specified event occurs.
+ * @returns A function to unsubscribe from the prefetcher events.
+ */
+function subscribeToPrefetcherEvents(type, callback) {
+    if (__lexPrefetcher !== undefined) {
+        return __lexPrefetcher.subscribeToEvent(type, callback);
+    }
+    return () => { };
+}
 // This is copied from lds-adapters-uiapi because the exports are totally messed up
 const notifyUpdateAvailableFactory = (luvio) => {
     return function notifyRecordUpdateAvailable(configs) {
@@ -9773,23 +9882,7 @@ function buildPredictorForContext(context) {
         watchPageLoadForPredictions() {
             // This chunk tells the prefetcher to receive events, send off any predictions we have from previous loads, then setup idle detection to stop predicting.
             __lexPrefetcher.startRecording();
-            // We only want to use cmpDef predictions on PROD code,
-            // as in dev, it is assumed that the definitions will change often
-            if (process.env.NODE_ENV === 'production') {
-                if (useCmpDefPredictions.isOpen({ fallback: false })) {
-                    window['$A'].installOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
-                }
-            }
-            onIdleDetected(() => {
-                __lexPrefetcher.stopRecording();
-                // We only want to use cmpDef predictions on PROD code,
-                // as in dev, it is assumed that the definitions will change often
-                if (process.env.NODE_ENV === 'production') {
-                    if (useCmpDefPredictions.isOpen({ fallback: false })) {
-                        window['$A'].uninstallOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
-                    }
-                }
-            });
+            onIdleDetected(() => __lexPrefetcher.stopRecording());
         },
         runPredictions() {
             if (isSameContext) {
@@ -9899,7 +9992,7 @@ function initializeOneStore(luvio) {
         buildServiceDescriptor$4(),
         buildServiceDescriptor$3(),
         buildServiceDescriptor$2$1(),
-        buildServiceDescriptor$1$1(),
+        buildServiceDescriptor$1$2(),
         buildServiceDescriptor$7(),
         buildLWCWireBindingsServiceDescriptor(),
         buildLWCGraphQLWireBindingsServiceDescriptor(),
@@ -9921,5 +10014,5 @@ function ldsEngineCreator() {
     return { name: 'ldsEngineCreator' };
 }
 
-export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.410.0-19e0e5d352
+export { LexRequestStrategy, PdlPrefetcherEventType, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, subscribeToPrefetcherEvents, unregisterRequestStrategy, whenPredictionsReady };
+// version: 1.411.0-193e3a20c1

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

@@ -1,6 +1,5 @@
 import { type LoggerService } from '@conduit-client/utils';
-import { Interceptors, type FetchServiceDescriptor } from '@conduit-client/service-fetch-network/v1';
+import { type FetchServiceDescriptor } from '@conduit-client/service-fetch-network/v1';
 import { RetryService } from '@conduit-client/service-retry/v1';
 export declare function buildLexRuntimeDefaultFetchServiceDescriptor(logger: LoggerService, retryService?: RetryService<Response>): FetchServiceDescriptor;
 export declare function buildLexRuntimeAllow5xxFetchServiceDescriptor(logger: LoggerService, retryService?: RetryService<Response>): FetchServiceDescriptor;
-export declare function buildLexConnectFetchServiceDescriptor<Context = any>(interceptors?: Interceptors<Context>, retryService?: RetryService<Response>): FetchServiceDescriptor;

package/dist/types/main.d.ts

@@ -1,9 +1,9 @@
 import { Luvio } from '@luvio/engine';
 import { KeyParamsRecord } from '@salesforce/lds-adapters-uiapi';
-import { ObjectHomePageContext, type RecordHomePageContext } from './predictive-loading';
+import { ObjectHomePageContext, PdlPrefetcherEventType, PrefetcherEventMap, type RecordHomePageContext } from './predictive-loading';
 import type { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
 import { type LexRequest } from './predictive-loading/lex';
-export { PdlRequestPriority } from './predictive-loading';
+export { PdlRequestPriority, PdlPrefetcherEventType } from './predictive-loading';
 export { LexRequestStrategy } from './predictive-loading/request-strategy/lex-request-strategy';
 /**
  * Registers a request strategy to be utilized by PDL.
@@ -19,6 +19,13 @@ export declare function registerRequestStrategy(...requestStrategy: LexRequestSt
 export declare function unregisterRequestStrategy(...requestStrategy: LexRequestStrategy[]): boolean | boolean[];
 export declare function whenPredictionsReady(callback: () => void): void;
 export declare function saveRequestAsPrediction(request: LexRequest): void;
+/**
+ * Subscribes to a specific prefetcher event type.
+ * @param type - The type of event to subscribe to.
+ * @param callback - The callback to invoke when the specified event occurs.
+ * @returns A function to unsubscribe from the prefetcher events.
+ */
+export declare function subscribeToPrefetcherEvents<T extends PdlPrefetcherEventType>(type: T, callback: (event: PrefetcherEventMap[T]) => void): () => void;
 export declare const notifyUpdateAvailableFactory: (luvio: Luvio) => (configs: Partial<KeyParamsRecord>[]) => Promise<void>;
 /**
  * @typedef {Object} RecordHomePageContext

package/dist/types/predictive-loading/prefetcher/events.d.ts

@@ -0,0 +1,25 @@
+import type { PredictivePrefetchPage } from '../pages';
+export declare enum PdlPrefetcherEventType {
+    STARTED_RECORDING = "started-recording",
+    STOPPED_RECORDING = "stopped-recording"
+}
+export type StartedRecordingEvent = {
+    type: PdlPrefetcherEventType.STARTED_RECORDING;
+    page: PredictivePrefetchPage<any, any>;
+};
+export type StoppedRecordingEvent = {
+    type: PdlPrefetcherEventType.STOPPED_RECORDING;
+    page: PredictivePrefetchPage<any, any>;
+};
+export type PrefetcherEvent = StartedRecordingEvent | StoppedRecordingEvent;
+export type PrefetcherEventMap = {
+    [PdlPrefetcherEventType.STARTED_RECORDING]: StartedRecordingEvent;
+    [PdlPrefetcherEventType.STOPPED_RECORDING]: StoppedRecordingEvent;
+};
+type ListenerFn<T extends PdlPrefetcherEventType> = (event: PrefetcherEventMap[T]) => void;
+export declare class PrefetcherEventEmitter {
+    private listeners;
+    subscribeTo<T extends PdlPrefetcherEventType>(type: T, listener: ListenerFn<T>): () => void;
+    emit<T extends PdlPrefetcherEventType>(event: PrefetcherEventMap[T]): void;
+}
+export {};

package/dist/types/predictive-loading/prefetcher/index.d.ts

@@ -1,2 +1,4 @@
 export * from './predictive-prefetcher';
 export * from './lex-predictive-prefetcher';
+export type { PrefetcherEvent, StartedRecordingEvent, StoppedRecordingEvent, PrefetcherEventMap, } from './events';
+export { PdlPrefetcherEventType } from './events';

package/dist/types/predictive-loading/prefetcher/lex-predictive-prefetcher.d.ts

@@ -5,11 +5,12 @@ import type { PrefetchRepository } from '../repository';
 import type { RequestEntry } from '../common';
 import type { LexContext, LexPrefetcherOptions, LexRequest } from '../lex';
 import type { RequestStrategyManager } from '../request-strategy-manager/request-strategy-manager';
+import { PrefetcherEventEmitter } from './events';
 export declare class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher<LexRequest, LexContext, LexDefaultPage<LexRequest, LexContext>> {
     protected options: LexPrefetcherOptions;
     page: LexDefaultPage<LexRequest, LexContext>;
     private requestStrategyManager;
-    constructor(context: LexContext, repository: PrefetchRepository<LexRequest>, requestRunner: RequestRunner<LexRequest>, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
+    constructor(context: LexContext, repository: PrefetchRepository<LexRequest>, requestRunner: RequestRunner<LexRequest>, eventEmitter: PrefetcherEventEmitter, requestStrategyManager: RequestStrategyManager, options: LexPrefetcherOptions);
     getPage(): LexDefaultPage<LexRequest, LexContext>;
     getAllPageRequests(): RequestEntry<LexRequest>[];
     getPredictedRequestsOrderedByPriority(): RequestEntry<LexRequest>[];

package/dist/types/predictive-loading/prefetcher/predictive-prefetcher.d.ts

@@ -2,18 +2,21 @@ import type { PrefetchRepository } from '../repository';
 import type { PredictivePrefetchPage } from '../pages';
 import type { RequestRunner } from '../request-runner';
 import type { BaseAdapterRequest } from '../request-strategy';
+import { PrefetcherEventEmitter, PdlPrefetcherEventType, PrefetcherEventMap } from './events';
 export declare abstract class ApplicationPredictivePrefetcher<Request extends BaseAdapterRequest, Context extends Record<string, any>, Page extends PredictivePrefetchPage<Request, Context>> {
     protected repository: PrefetchRepository<Request>;
     protected requestRunner: RequestRunner<Request>;
+    protected eventEmitter: PrefetcherEventEmitter;
     private _context;
     isRecording: boolean;
     totalRequestCount: Number;
     page: Page;
     queuedPredictionRequests: Request[];
-    protected constructor(context: Context, repository: PrefetchRepository<Request>, requestRunner: RequestRunner<Request>);
+    protected constructor(context: Context, repository: PrefetchRepository<Request>, requestRunner: RequestRunner<Request>, eventEmitter: PrefetcherEventEmitter);
     abstract getPage(): Page;
     set context(value: Context);
     get context(): Context;
+    subscribeToEvent<T extends PdlPrefetcherEventType>(type: T, callback: (event: PrefetcherEventMap[T]) => void): () => void;
     stopRecording(): Promise<void>;
     startRecording(): void;
     saveRequest(request: Request): void;

package/dist/types/retry-interceptors/csrf-retry.d.ts

@@ -0,0 +1,2 @@
+import { RetryInterceptor } from '@conduit-client/service-fetch-network/v1';
+export declare function buildCsrfRetryInterceptor(): RetryInterceptor;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.410.0",
+    "version": "1.411.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,49 +34,49 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@conduit-client/service-provisioner": "3.6.1",
-        "@conduit-client/tools-core": "3.6.1",
-        "@salesforce/lds-adapters-apex": "^1.410.0",
-        "@salesforce/lds-adapters-uiapi": "^1.410.0",
-        "@salesforce/lds-ads-bridge": "^1.410.0",
-        "@salesforce/lds-aura-storage": "^1.410.0",
-        "@salesforce/lds-bindings": "^1.410.0",
-        "@salesforce/lds-instrumentation": "^1.410.0",
-        "@salesforce/lds-network-aura": "^1.410.0",
-        "@salesforce/lds-network-fetch": "^1.410.0",
+        "@conduit-client/service-provisioner": "3.6.3",
+        "@conduit-client/tools-core": "3.6.3",
+        "@salesforce/lds-adapters-apex": "^1.411.0",
+        "@salesforce/lds-adapters-uiapi": "^1.411.0",
+        "@salesforce/lds-ads-bridge": "^1.411.0",
+        "@salesforce/lds-aura-storage": "^1.411.0",
+        "@salesforce/lds-bindings": "^1.411.0",
+        "@salesforce/lds-instrumentation": "^1.411.0",
+        "@salesforce/lds-network-aura": "^1.411.0",
+        "@salesforce/lds-network-fetch": "^1.411.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@conduit-client/command-aura-graphql-normalized-cache-control": "3.6.1",
-        "@conduit-client/command-aura-network": "3.6.1",
-        "@conduit-client/command-aura-normalized-cache-control": "3.6.1",
-        "@conduit-client/command-aura-resource-cache-control": "3.6.1",
-        "@conduit-client/command-fetch-network": "3.6.1",
-        "@conduit-client/command-http-graphql-normalized-cache-control": "3.6.1",
-        "@conduit-client/command-http-normalized-cache-control": "3.6.1",
-        "@conduit-client/command-ndjson": "3.6.1",
-        "@conduit-client/command-network": "3.6.1",
-        "@conduit-client/command-sse": "3.6.1",
-        "@conduit-client/command-streaming": "3.6.1",
-        "@conduit-client/service-aura-network": "3.6.1",
-        "@conduit-client/service-bindings-imperative": "3.6.1",
-        "@conduit-client/service-bindings-lwc": "3.6.1",
-        "@conduit-client/service-cache": "3.6.1",
-        "@conduit-client/service-cache-control": "3.6.1",
-        "@conduit-client/service-cache-inclusion-policy": "3.6.1",
-        "@conduit-client/service-feature-flags": "3.6.1",
-        "@conduit-client/service-fetch-network": "3.6.1",
-        "@conduit-client/service-instrument-command": "3.6.1",
-        "@conduit-client/service-pubsub": "3.6.1",
-        "@conduit-client/service-store": "3.6.1",
-        "@conduit-client/utils": "3.6.1",
+        "@conduit-client/command-aura-graphql-normalized-cache-control": "3.6.3",
+        "@conduit-client/command-aura-network": "3.6.3",
+        "@conduit-client/command-aura-normalized-cache-control": "3.6.3",
+        "@conduit-client/command-aura-resource-cache-control": "3.6.3",
+        "@conduit-client/command-fetch-network": "3.6.3",
+        "@conduit-client/command-http-graphql-normalized-cache-control": "3.6.3",
+        "@conduit-client/command-http-normalized-cache-control": "3.6.3",
+        "@conduit-client/command-ndjson": "3.6.3",
+        "@conduit-client/command-network": "3.6.3",
+        "@conduit-client/command-sse": "3.6.3",
+        "@conduit-client/command-streaming": "3.6.3",
+        "@conduit-client/service-aura-network": "3.6.3",
+        "@conduit-client/service-bindings-imperative": "3.6.3",
+        "@conduit-client/service-bindings-lwc": "3.6.3",
+        "@conduit-client/service-cache": "3.6.3",
+        "@conduit-client/service-cache-control": "3.6.3",
+        "@conduit-client/service-cache-inclusion-policy": "3.6.3",
+        "@conduit-client/service-feature-flags": "3.6.3",
+        "@conduit-client/service-fetch-network": "3.6.3",
+        "@conduit-client/service-instrument-command": "3.6.3",
+        "@conduit-client/service-pubsub": "3.6.3",
+        "@conduit-client/service-store": "3.6.3",
+        "@conduit-client/utils": "3.6.3",
         "@luvio/network-adapter-composable": "0.158.7",
         "@luvio/network-adapter-fetch": "0.158.7",
         "@lwc/state": "^0.23.0",
-        "@salesforce/lds-adapters-onestore-graphql": "^1.410.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.410.0",
-        "@salesforce/lds-luvio-service": "^1.410.0",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.410.0"
+        "@salesforce/lds-adapters-onestore-graphql": "^1.411.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.411.0",
+        "@salesforce/lds-luvio-service": "^1.411.0",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.411.0"
     },
     "luvioBundlesize": [
         {
@@ -84,7 +84,7 @@
             "maxSize": {
                 "none": "350 kB",
                 "min": "190 kB",
-                "compressed": "57 kB"
+                "compressed": "57.2 kB"
             }
         }
     ],