@salesforce/lds-runtime-aura 1.459.0 → 1.461.0

package/dist/ldsEngineCreator.js

@@ -13,12 +13,8 @@
  */
 /* proxy-compat-disable */
 import { HttpStatusCode as HttpStatusCode$2, InMemoryStore, Environment, Luvio, InMemoryStoreQueryEvaluator } from 'force/luvioEngine';
-import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
-import useLocalStorage from '@salesforce/gate/lds.pdl.useLocalStorage';
 import useOneStoreGraphql from '@salesforce/gate/lds.oneStoreGraphqlEnabled.ltng';
-import canCombineRecordLayoutRequests from '@salesforce/gate/lds.pdl.canCombineRecordLayoutRequests';
-import { GetApexWireAdapterFactory, registerPrefetcher as registerPrefetcher$1 } from 'force/ldsAdaptersApex';
-import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, coerceLayoutTypeArray, coerceLayoutModeArray, 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 { instrument, buildRecordRepKeyFromId, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, RecordRepresentationVersion } from 'force/ldsAdaptersUiapi';
 import { getInstrumentation } from 'o11y/client';
 import { findExecutableOperation, buildGraphQLInputExtension, addTypenameToDocument } from 'force/luvioGraphqlNormalization';
 import { print, resolveAndValidateGraphQLConfig, toGraphQLErrorResponse } from 'force/luvioOnestoreGraphqlParser';
@@ -30,11 +26,10 @@ import { ThirdPartyTracker } from 'instrumentation:thirdPartyTracker';
 import { markStart, markEnd, counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer, mark } from 'instrumentation/service';
 import { instrument as instrument$2, isCsrfMethod, getFetchMethod, isRetryableMethod, isRetryableReadPost, compilePathMatchers, setupLexNetworkAdapter, UIAPI_PUBLIC_PATHS, UIAPI_PRIVATE_PATHS, isRetryableOperationType } from 'force/ldsNetworkFetch';
 import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$3 } from 'force/ldsBindings';
-import { stateManagerInstrumentation, OperationTypeValue, LRUCache, instrumentAdapter, instrumentLuvio, logMessage as logMessage$1, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, logError as logError$2, setLdsNetworkAdapterInstrumentation, executeAsyncActivity, METRIC_KEYS, onIdleDetected } from 'force/ldsInstrumentation';
+import { stateManagerInstrumentation, OperationTypeValue, LRUCache, instrumentAdapter, instrumentLuvio, logMessage as logMessage$1, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, logError as logError$2, setLdsNetworkAdapterInstrumentation } 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 applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
 import { pageScopedCache } from 'instrumentation/utility';
 import lightningConnectEnabled from '@salesforce/gate/ui.services.LightningConnect.enabled';
 import bypassAppRestrictionEnabled from '@salesforce/gate/ui.services.LightningConnect.BypassAppRestriction.enabled';
@@ -44,9 +39,8 @@ import useHttpUiapiOneRuntime from '@salesforce/gate/lds.useHttpUiapiOneRuntime'
 import useHttpUiapiAuraSites from '@salesforce/gate/lds.usehttpuiapiaurasites';
 import auraBasedRequestsEnabled from '@salesforce/gate/ui.services.auraBasedRequests.enabled';
 import disableCreateContentDocumentAndVersionHTTPLexRuntime from '@salesforce/gate/lds.lex.http.disableCreateContentDocumentAndVersion';
-import useHotspotLimit from '@salesforce/gate/lds.pdl.useHotspotLimit';
-import { createStorage, clearStorages } from 'force/ldsDurableStorage';
 import { registerSubRequestNetworkAdapter } from 'force/ldsNetwork';
+import { clearStorages, createStorage } from 'force/ldsDurableStorage';
 
 const { create: create$1, freeze, keys: keys$2, entries: entries$1 } = Object;
 const { isArray: isArray$4 } = Array;
@@ -175,7 +169,7 @@ function rejectedPromiseLike$2(reason) {
 function isPromiseLike$2(x) {
   return typeof x?.then === "function";
 }
-function stableJSONStringify$2(node) {
+function stableJSONStringify$1(node) {
   const withToJSON = node;
   if (withToJSON && typeof withToJSON.toJSON === "function") {
     node = withToJSON.toJSON();
@@ -197,7 +191,7 @@ function stableJSONStringify$2(node) {
       if (i) {
         out += ",";
       }
-      out += stableJSONStringify$2(node[i]) || "null";
+      out += stableJSONStringify$1(node[i]) || "null";
     }
     return out + "]";
   }
@@ -209,7 +203,7 @@ function stableJSONStringify$2(node) {
   out = "";
   for (i = 0; i < objKeys.length; i++) {
     const key = objKeys[i];
-    const value = stableJSONStringify$2(record[key]);
+    const value = stableJSONStringify$1(record[key]);
     if (!value) {
       continue;
     }
@@ -599,7 +593,7 @@ function rejectedPromiseLike$1(reason) {
 function isPromiseLike$1(x) {
   return typeof x?.then === "function";
 }
-function deepEquals$1(x, y) {
+function deepEquals(x, y) {
   if (x === void 0) {
     return y === void 0;
   } else if (x === null) {
@@ -611,7 +605,7 @@ function deepEquals$1(x, y) {
       return false;
     }
     for (let i = 0; i < x.length; ++i) {
-      if (!deepEquals$1(x[i], y[i])) {
+      if (!deepEquals(x[i], y[i])) {
         return false;
       }
     }
@@ -627,7 +621,7 @@ function deepEquals$1(x, y) {
     }
     for (let i = 0; i < xkeys.length; ++i) {
       const key = xkeys[i];
-      if (!deepEquals$1(
+      if (!deepEquals(
         x[key],
         y[key]
       )) {
@@ -908,7 +902,7 @@ class CacheControlCommand extends BaseCommand {
    * @todo This should likely be abstract in v2. For v1, provide default comparison logic.
    */
   equals(result1, result2) {
-    return deepEquals$1(result1, result2);
+    return deepEquals(result1, result2);
   }
   /**
    * Hook method called after a network request completes
@@ -2602,7 +2596,7 @@ function buildServiceDescriptor$d(luvio) {
         },
     };
 }
-// version: 1.459.0-414dbbb5aa
+// version: 1.461.0-37b1c9d1cb
 
 class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheControlCommand {
   constructor(config, documentRootType, services) {
@@ -2941,7 +2935,7 @@ function buildServiceDescriptor$9(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.459.0-414dbbb5aa
+// version: 1.461.0-37b1c9d1cb
 
 class RetryService {
   constructor(defaultRetryPolicy) {
@@ -4221,7 +4215,7 @@ function cacheKeyFor(params) {
   if (params === void 0) {
     return "jwt:";
   }
-  return `jwt:${stableJSONStringify$2(params) ?? ""}`;
+  return `jwt:${stableJSONStringify$1(params) ?? ""}`;
 }
 let defaultLogger = {
   trace: () => {
@@ -5250,7 +5244,7 @@ const { stringify: stringify$1 } = JSON;
  * @param data Data to be JSON-stringified.
  * @returns JSON.stringified value with consistent ordering of keys.
  */
-function stableJSONStringify$1(node) {
+function stableJSONStringify(node) {
     // This is for Date values.
     if (node && node.toJSON && typeof node.toJSON === 'function') {
         // eslint-disable-next-line no-param-reassign
@@ -5276,7 +5270,7 @@ function stableJSONStringify$1(node) {
             if (i) {
                 out += ',';
             }
-            out += stableJSONStringify$1(node[i]) || 'null';
+            out += stableJSONStringify(node[i]) || 'null';
         }
         return out + ']';
     }
@@ -5287,7 +5281,7 @@ function stableJSONStringify$1(node) {
     out = '';
     for (i = 0; i < keys$1.length; i++) {
         const key = keys$1[i];
-        const value = stableJSONStringify$1(node[key]);
+        const value = stableJSONStringify(node[key]);
         if (!value) {
             continue;
         }
@@ -5422,7 +5416,7 @@ class Instrumentation {
      * @param ttl TTL for the wire adapter.
      */
     logAdapterCacheMissOutOfTtlDuration(name, config, ttlMissStats, currentCacheMissTimestamp, ttl) {
-        const configKey = `${name}:${stableJSONStringify$1(config)}`;
+        const configKey = `${name}:${stableJSONStringify(config)}`;
         const existingCacheMissTimestamp = this.adapterCacheMisses.get(configKey);
         this.adapterCacheMisses.set(configKey, currentCacheMissTimestamp);
         if (existingCacheMissTimestamp !== undefined) {
@@ -5947,7 +5941,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.459.0-eda2fb69a9
+// version: 1.461.0-55ae54e753
 
 const auraClientService = getAuraClientService();
 const defaultConfig = {
@@ -5968,11 +5962,6 @@ if (auraClientService?.maxAllowedParallelXHRCounts) {
         config.forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
     });
 }
-if (!applyPredictionRequestLimit.isOpen({ fallback: false })) {
-    configService.set('lex', (config) => {
-        config.maxAllowedParallelXHRCounts = 1000;
-    });
-}
 
 const forceRecordTransactionsDisabled = configService.config.forceRecordTransactionsDisabled;
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -7883,2186 +7872,116 @@ function buildGuardedLegacyJwtRequestInterceptor(logger) {
     return (args) => hasAuthorizationHeader(args) ? resolvedPromiseLike$2(args) : legacyInterceptor(args);
 }
 
-const PDL_EXECUTE_ASYNC_OPTIONS = {
-    LOG_ERROR_ONLY: true,
-    ERROR_SCOPE: 'lds-predictive-loading',
-};
-
-class PredictivePrefetchPage {
-    constructor(context, similarContext) {
-        this.context = context;
-        this.similarContext = similarContext;
-    }
-    getExactKey() {
-        return { ...this.context };
-    }
-    getSimilarKey() {
-        return { ...this.similarContext };
-    }
-}
-
-class LexDefaultPage extends PredictivePrefetchPage {
-    constructor(context, similarContext) {
-        super(context, similarContext);
-    }
-    supportsRequest(_request) {
-        return true;
-    }
-    buildSaveRequestData(request) {
-        return [{ key: this.getExactKey(), request }];
-    }
-    resolveSimilarRequest(similarRequest) {
-        return similarRequest;
-    }
-    getAlwaysRunRequests() {
-        return [];
-    }
-    shouldReduceAlwaysRequestsWithPredictions() {
-        return true;
-    }
-    shouldExecuteAlwaysRequestByThemself() {
-        return false;
+class NoComposedAdapterTypeError extends TypeError {
+    constructor(message, resourceRequest) {
+        super(message);
+        this.resourceRequest = resourceRequest;
     }
 }
 
-// Note: exported enum for core usage.
-var PdlRequestPriority;
-(function (PdlRequestPriority) {
-    PdlRequestPriority[PdlRequestPriority["LOW"] = 0] = "LOW";
-    PdlRequestPriority[PdlRequestPriority["NORMAL"] = 1] = "NORMAL";
-    PdlRequestPriority[PdlRequestPriority["HIGH"] = 2] = "HIGH";
-})(PdlRequestPriority || (PdlRequestPriority = {}));
-class RequestStrategy {
-    getRequestPriority(_request, _context) {
-        return 1 /* RequestPriority.NORMAL */;
-    }
-    /**
-     * Perform any transformations required to prepare the request for saving.
-     *
-     * e.g. If the request is for a record, we move all fields in the fields array
-     * into the optionalFields array
-     *
-     * @param request - The request to transform
-     * @returns
-     */
-    transformForSave(request, _context) {
-        return request;
-    }
-    /**
-     * Transforms the request for saving similar requests
-     * @param request Request to transform for saving similar requests
-     * @returns Transformed request
-     */
-    transformForSaveSimilarRequest(request, _context) {
-        return this.transformForSave(request, _context);
-    }
-    /**
-     * Filter requests to only those that are for this strategy.
-     *
-     * @param unfilteredRequests array of requests to filter
-     * @returns
-     */
-    filterRequests(unfilteredRequests) {
-        return unfilteredRequests.filter((entry) => entry.request.adapterName === this.adapterName);
-    }
-    /**
-     * Reduce requests by combining those based on a strategies implementations
-     * of canCombine and combineRequests.
-     * @param unfilteredRequests array of requests to filter
-     * @returns
-     */
-    reduce(unfilteredRequests) {
-        const requests = this.filterRequests(unfilteredRequests);
-        const visitedRequests = new Set();
-        const reducedRequests = [];
-        for (let i = 0, n = requests.length; i < n; i++) {
-            const currentRequest = requests[i];
-            if (!visitedRequests.has(currentRequest)) {
-                const combinedRequest = { ...currentRequest };
-                for (let j = i + 1; j < n; j++) {
-                    const hasNotBeenVisited = !visitedRequests.has(requests[j]);
-                    const canCombineConfigs = this.canCombine(combinedRequest.request.config, requests[j].request.config);
-                    if (hasNotBeenVisited && canCombineConfigs) {
-                        combinedRequest.request.config = this.combineRequests(combinedRequest.request.config, requests[j].request.config);
-                        if (combinedRequest.requestMetadata.requestTime >
-                            requests[j].requestMetadata.requestTime) {
-                            // This logic is debateable - Currently this always assigns the lowest requestTime to a reduced request.
-                            combinedRequest.requestMetadata.requestTime =
-                                requests[j].requestMetadata.requestTime;
-                        }
-                        visitedRequests.add(requests[j]);
-                    }
-                }
-                reducedRequests.push(combinedRequest);
-                visitedRequests.add(currentRequest);
-            }
-        }
-        return reducedRequests;
-    }
-    /**
-     * Check if two requests can be combined.
-     *
-     * By default, requests are not combinable.
-     * @param reqA config of request A
-     * @param reqB config of request B
-     * @returns
-     */
-    canCombine(_reqA, _reqB) {
-        return false;
-    }
-    /**
-     * Takes two request configs and combines them into a single request config.
-     *
-     * @param reqA config of request A
-     * @param reqB config of request B
-     * @returns
-     */
-    combineRequests(reqA, _reqB) {
-        // By default, this should never be called since requests aren't combinable
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error('Not implemented');
+function buildComposableNetworkAdapter(composedAdapters) {
+    return (resourceRequest, resourceRequestContext) => {
+        const composedAdapter = composedAdapters.find((adapter) => adapter.shouldHandleRequest(resourceRequest));
+        if (composedAdapter === undefined) {
+            throw new NoComposedAdapterTypeError('There are no network adapters that can process the request.', resourceRequest);
         }
-        return reqA;
-    }
-    /**
-     * Checks adapter config against request context to determine if the request is context dependent.
-     *
-     * By default, requests are not context dependent.
-     * @param request
-     * @returns
-     */
-    isContextDependent(_context, _request) {
-        return false;
-    }
+        return composedAdapter.adapter(resourceRequest, resourceRequestContext);
+    };
 }
 
-class LexRequestStrategy extends RequestStrategy {
-    /**
-     * Whether or not requests from this strategies can be boxcarred by Aura.
-     * If they are, the lex prefetcher will run predictions of this strategy with a limit,
-     * to avoid predictions being boxcared.
-     *
-     * @returns boolean
-     */
-    get isBoxcarable() {
-        return true;
+function getComposedAdapters() {
+    const composedAdapters = [
+        composedNetworkAdapter$1, // SFAP adapter
+    ];
+    // Add the UIAPI Fetch adapter if any of its API paths are enabled
+    if (isFetchAdapterEnabled()) {
+        composedAdapters.push(composedFetchNetworkAdapter); // UIAPI Fetch adapter
     }
+    return composedAdapters;
 }
-
-const LDS_PDL_CMP_IDENTIFIER = 'lds:pdl';
-const DEFAULT_RESOURCE_CONTEXT = {
-    sourceContext: {
-        tagName: LDS_PDL_CMP_IDENTIFIER,
-        actionConfig: {
-            background: false,
-            hotspot: true,
-            longRunning: false,
+const composedNetworkAdapter = buildComposableNetworkAdapter([
+    ...getComposedAdapters(),
+    // The aura network adapter must be the default.
+    {
+        shouldHandleRequest() {
+            return true;
         },
+        adapter: auraNetworkAdapter,
     },
-};
-class LuvioAdapterRequestStrategy extends LexRequestStrategy {
-    constructor(luvio) {
-        super();
-        this.luvio = luvio;
-    }
-    execute(config, options = {}) {
-        return this.adapterFactory(this.luvio)(config, this.createAdapterContext(options));
-    }
-    createAdapterContext(options) {
-        return {
-            ...DEFAULT_RESOURCE_CONTEXT,
-            sourceContext: {
-                ...DEFAULT_RESOURCE_CONTEXT.sourceContext,
-                actionConfig: {
-                    ...DEFAULT_RESOURCE_CONTEXT.sourceContext.actionConfig,
-                    hotspot: !options.disableHotspot,
-                },
-            },
-        };
-    }
-}
-
-const GET_RECORD_AVATARS_ADAPTER_NAME = 'getRecordAvatars';
-function normalizeRecordIds$1(recordIds) {
-    if (!Array.isArray(recordIds)) {
-        return [recordIds];
-    }
-    return recordIds;
-}
-class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RECORD_AVATARS_ADAPTER_NAME;
-        this.adapterFactory = getRecordAvatarsAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordIds: [context.recordId],
-            },
-        };
-    }
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave({
-            ...request,
-            config: {
-                ...request.config,
-                recordIds: ['*'],
-            },
-        });
-    }
-    isContextDependent(context, request) {
-        return (request.config.recordIds &&
-            (context.recordId === request.config.recordIds || // some may set this as string instead of array
-                (request.config.recordIds.length === 1 &&
-                    request.config.recordIds[0] === context.recordId)));
-    }
-    canCombine(reqA, reqB) {
-        return reqA.formFactor === reqB.formFactor;
-    }
-    combineRequests(reqA, reqB) {
-        const combined = { ...reqA };
-        combined.recordIds = Array.from(new Set([...normalizeRecordIds$1(reqA.recordIds), ...normalizeRecordIds$1(reqB.recordIds)]));
-        return combined;
-    }
-}
+]);
+// Route dispatcher-synthesized sub-requests (e.g. aggregate-ui) back through
+// the composed adapter so shouldHandleRequest and interceptors apply uniformly.
+registerSubRequestNetworkAdapter(composedNetworkAdapter);
 
-const GET_RECORD_ADAPTER_NAME = 'getRecord';
-const COERCE_FIELD_ID_ARRAY_OPTIONS = { onlyQualifiedFieldNames: true };
-function isFieldsRequest(config) {
-    return (config.layoutTypes === undefined &&
-        config.modes === undefined &&
-        (config.fields !== undefined || config.optionalFields !== undefined));
-}
-function isCombinableLayoutRequest(config) {
-    // We will only consider a layout request combinable if it is a single layout type request
-    // and the only request parameters are:
-    // - layoutTypes
-    // - optionalFields
-    // - modes
-    const hasExtraParams = config.childRelationships !== undefined ||
-        config.pageSize !== undefined ||
-        config.updateMru !== undefined;
-    return config.layoutTypes !== undefined && !hasExtraParams;
-}
-function areCombinableLayoutRequests(reqA, reqB) {
-    const normilizedLayoutTypesA = coerceLayoutTypeArray(reqA.layoutTypes) || [];
-    const normilizedLayoutTypesB = coerceLayoutTypeArray(reqB.layoutTypes) || [];
-    // Let's only combine when the layoutTypes are the same
-    return (isCombinableLayoutRequest(reqA) &&
-        isCombinableLayoutRequest(reqB) &&
-        reqA.recordId === reqB.recordId &&
-        normilizedLayoutTypesA.length === normilizedLayoutTypesB.length &&
-        normilizedLayoutTypesA.every((type, index) => type === normilizedLayoutTypesB[index]));
-}
-class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor(luvio, canCombineRecordLayoutRequests = false) {
-        super(luvio);
-        this.canCombineRecordLayoutRequests = canCombineRecordLayoutRequests;
-        this.adapterName = GET_RECORD_ADAPTER_NAME;
-        this.adapterFactory = getRecordAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordId: context.recordId,
-            },
-        };
-    }
-    transformForSave(request) {
-        if (request.config.fields === undefined && request.config.optionalFields === undefined) {
-            return request;
-        }
-        let fields = coerceFieldIdArray(request.config.fields, COERCE_FIELD_ID_ARRAY_OPTIONS) || [];
-        let optionalFields = coerceFieldIdArray(request.config.optionalFields, COERCE_FIELD_ID_ARRAY_OPTIONS) || [];
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                fields: undefined,
-                optionalFields: [...fields, ...optionalFields],
-            },
-        };
-    }
-    canCombine(reqA, reqB) {
-        // must be same record and either both are fields requests or both are combinable layout requests
-        return (reqA.recordId === reqB.recordId &&
-            ((isFieldsRequest(reqA) && isFieldsRequest(reqB)) ||
-                (this.canCombineRecordLayoutRequests && areCombinableLayoutRequests(reqA, reqB))));
-    }
-    combineRequests(reqA, reqB) {
-        if (isFieldsRequest(reqA)) {
-            return this.combineFieldsRequests(reqA, reqB);
-        }
-        else {
-            return this.combineLayoutRequests(reqA, reqB);
-        }
-    }
-    combineLayoutRequests(reqA, reqB) {
-        const combined = {
-            recordId: reqA.recordId,
-            layoutTypes: coerceLayoutTypeArray(reqA.layoutTypes),
-        };
-        // combine Modes.
-        // Note: the || ['View'] is important; it is to cover the case in which it needs to
-        // combine mode: undefined (defaults to View) with mode: ['something else than View']
-        const modeA = coerceLayoutModeArray(reqA.modes) || ['View'];
-        const modeB = coerceLayoutModeArray(reqB.modes) || ['View'];
-        if (reqA.modes !== undefined || reqB.modes !== undefined) {
-            combined.modes = Array.from(new Set([...modeA, ...modeB]));
-        }
-        // combine Optional Fields.
-        const optionalFieldsA = coerceFieldIdArray(reqA.optionalFields, COERCE_FIELD_ID_ARRAY_OPTIONS) || [];
-        const optionalFieldsB = coerceFieldIdArray(reqB.optionalFields, COERCE_FIELD_ID_ARRAY_OPTIONS) || [];
-        if (optionalFieldsA !== undefined || optionalFieldsB !== undefined) {
-            combined.optionalFields = Array.from(new Set([...optionalFieldsA, ...optionalFieldsB]));
-        }
-        return combined;
-    }
-    combineFieldsRequests(reqA, reqB) {
-        const fields = new Set();
-        const optionalFields = new Set();
-        if (reqA.fields !== undefined) {
-            reqA.fields.forEach((field) => fields.add(field));
-        }
-        if (reqB.fields !== undefined) {
-            reqB.fields.forEach((field) => fields.add(field));
-        }
-        if (reqA.optionalFields !== undefined) {
-            reqA.optionalFields.forEach((field) => optionalFields.add(field));
-        }
-        if (reqB.optionalFields !== undefined) {
-            reqB.optionalFields.forEach((field) => optionalFields.add(field));
+const OBJECT_INFO_PREFIX = 'UiApi::ObjectInfoRepresentation:';
+/**
+ * Watch a Luvio instance for metadata changes.
+ */
+function setupMetadataWatcher(luvio) {
+    // Watch for object info changes. Since we don't have enough information to understand to which
+    // extent an object info change may impact the application the only thing we do is to clear all
+    // the  persistent storages.
+    luvio.storeWatch(OBJECT_INFO_PREFIX, (entries) => {
+        for (let i = 0, len = entries.length; i < len; i++) {
+            const entry = entries[i];
+            const isObjectInfoUpdated = entry.inserted === false;
+            if (isObjectInfoUpdated) {
+                logObjectInfoChanged();
+                clearStorages().catch(() => {
+                    /* noop */
+                });
+                break;
+            }
         }
-        return {
-            recordId: reqA.recordId,
-            fields: Array.from(fields),
-            optionalFields: Array.from(optionalFields),
-        };
-    }
-    isContextDependent(context, request) {
-        return request.config.recordId === context.recordId;
-    }
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave({
-            ...request,
-            config: {
-                ...request.config,
-                recordId: '*',
-            },
-        });
-    }
-}
-
-const GET_RECORDS_ADAPTER_NAME = 'getRecords';
-class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RECORDS_ADAPTER_NAME;
-        this.adapterFactory = getRecordsAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                records: [{ ...similarRequest.config.records[0], recordIds: [context.recordId] }],
-            },
-        };
-    }
-    isContextDependent(context, request) {
-        const isSingleRecordRequest = request.config.records.length === 1 && request.config.records[0].recordIds.length === 1;
-        return isSingleRecordRequest && request.config.records[0].recordIds[0] === context.recordId;
-    }
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave({
-            ...request,
-            config: {
-                ...request.config,
-                records: [
-                    {
-                        ...request.config.records[0],
-                        recordIds: ['*'],
-                    },
-                ],
-            },
-        });
-    }
+    });
 }
 
-const GET_RECORD_ACTIONS_ADAPTER_NAME = 'getRecordActions';
-function normalizeRecordIds(recordIds) {
-    if (!isArray(recordIds)) {
-        return [recordIds];
-    }
-    return recordIds;
+class CacheInclusionPolicyService {
 }
-function normalizeApiNames(apiNames) {
-    if (apiNames === undefined || apiNames === null) {
-        return [];
-    }
-    return isArray(apiNames) ? apiNames : [apiNames];
+class Ok {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
 }
-class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RECORD_ACTIONS_ADAPTER_NAME;
-        this.adapterFactory = getRecordActionsAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordIds: [context.recordId],
-            },
-        };
-    }
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave({
-            ...request,
-            config: {
-                ...request.config,
-                recordIds: ['*'],
-            },
-        });
-    }
-    canCombine(reqA, reqB) {
-        return (reqA.retrievalMode === reqB.retrievalMode &&
-            reqA.formFactor === reqB.formFactor &&
-            (reqA.actionTypes || []).toString() === (reqB.actionTypes || []).toString() &&
-            (reqA.sections || []).toString() === (reqB.sections || []).toString());
-    }
-    combineRequests(reqA, reqB) {
-        const combined = { ...reqA };
-        // let's merge the recordIds
-        combined.recordIds = Array.from(new Set([...normalizeRecordIds(reqA.recordIds), ...normalizeRecordIds(reqB.recordIds)]));
-        if (combined.retrievalMode === 'ALL') {
-            const combinedSet = new Set([
-                ...normalizeApiNames(combined.apiNames),
-                ...normalizeApiNames(reqB.apiNames),
-            ]);
-            combined.apiNames = Array.from(combinedSet);
-        }
-        return combined;
-    }
-    isContextDependent(context, request) {
-        return (request.config.recordIds &&
-            (context.recordId === request.config.recordIds || // some may set this as string instead of array
-                (request.config.recordIds.length === 1 &&
-                    request.config.recordIds[0] === context.recordId)));
+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;
 }
-
-const GET_OBJECT_INFO_BATCH_ADAPTER_NAME = 'getObjectInfos';
-/**
- * Returns true if A is a superset of B
- * @param a
- * @param b
- */
-function isSuperSet(a, b) {
-    return b.every((oan) => a.has(oan));
+function addAllToSet(targetSet, sourceSet) {
+  for (const element of sourceSet) {
+    targetSet.add(element);
+  }
 }
-class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_OBJECT_INFO_BATCH_ADAPTER_NAME;
-        this.adapterFactory = getObjectInfosAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest) {
-        return similarRequest;
-    }
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                // (!): if we are saving this request is because the adapter already verified is valid.
-                objectApiNames: coerceObjectIdArray(request.config.objectApiNames),
-            },
-        };
-    }
-    /**
-     * Reduces the given GetObjectInfosRequest requests by eliminating those for which config.objectApiNames
-     * is a subset of another GetObjectInfosRequest.
-     *
-     * @param unfilteredRequests - Array of unfiltered requests
-     * @returns RequestEntry<GetObjectInfosRequest>[] - Array of reduced requests
-     */
-    reduce(unfilteredRequests) {
-        // Filter and sort requests by the length of objectApiNames in ascending order.
-        // This ensures a superset of request (i) can only be found in a request (j) such that i < j.
-        const objectInfosRequests = this.filterRequests(unfilteredRequests).sort((a, b) => a.request.config.objectApiNames.length - b.request.config.objectApiNames.length);
-        // Convert request configurations to sets for easier comparison, avoiding a new set construction each iteration.
-        const requestConfigAsSet = objectInfosRequests.map((r) => new Set(r.request.config.objectApiNames));
-        const reducedRequests = [];
-        // Iterate over each request to determine if it is a subset of others
-        for (let i = 0, n = objectInfosRequests.length; i < n; i++) {
-            const current = objectInfosRequests[i];
-            const { request: { config: currentRequestConfig }, requestMetadata: currentRequestMetadata, } = current;
-            let isCurrentSubsetOfOthers = false;
-            // Check if the current request is a subset of any subsequent requests
-            for (let j = i + 1; j < n; j++) {
-                const possibleSuperset = objectInfosRequests[j];
-                if (isSuperSet(requestConfigAsSet[j], currentRequestConfig.objectApiNames)) {
-                    isCurrentSubsetOfOthers = true;
-                    if (currentRequestMetadata.requestTime <
-                        possibleSuperset.requestMetadata.requestTime) {
-                        possibleSuperset.requestMetadata.requestTime =
-                            currentRequestMetadata.requestTime;
-                    }
-                }
-            }
-            if (!isCurrentSubsetOfOthers) {
-                reducedRequests.push(current);
-            }
+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 reducedRequests;
+        return rejectedPromiseLike(e);
+      }
     }
-}
-
-const GET_OBJECT_INFO_ADAPTER_NAME = 'getObjectInfo';
-class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_OBJECT_INFO_ADAPTER_NAME;
-        this.adapterFactory = getObjectInfoAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                objectApiName: context.objectApiName,
-            },
-        };
-    }
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                // (!): if we are saving this request is because the adapter already verified is valid.
-                objectApiName: coerceObjectId(request.config.objectApiName),
-            },
-        };
-    }
-    isContextDependent(context, request) {
-        return (request.config.objectApiName !== undefined &&
-            context.objectApiName === request.config.objectApiName);
-    }
-    /**
-     * This method returns GetObjectInfoRequest[] that won't be part of a batch (getObjectInfos) request.
-     *
-     * @param unfilteredRequests all prediction requests
-     * @returns
-     */
-    reduce(unfilteredRequests) {
-        const objectApiNamesInBatchRequest = unfilteredRequests.filter((entry) => entry.request.adapterName === GET_OBJECT_INFO_BATCH_ADAPTER_NAME).reduce((acc, { request }) => {
-            request.config.objectApiNames.forEach((apiName) => acc.add(apiName));
-            return acc;
-        }, new Set());
-        const singleRequests = this.filterRequests(unfilteredRequests);
-        return singleRequests.filter((singleEntry) => {
-            return !objectApiNamesInBatchRequest.has(singleEntry.request.config.objectApiName);
-        });
-    }
-}
-
-const GET_RELATED_LISTS_ACTIONS_ADAPTER_NAME = 'getRelatedListsActions';
-function isReduceAbleRelatedListConfig(config) {
-    return config.relatedListsActionParameters.every((rlReq) => {
-        return rlReq.relatedListId !== undefined && keys(rlReq).length === 1;
-    });
-}
-class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RELATED_LISTS_ACTIONS_ADAPTER_NAME;
-        this.adapterFactory = getRelatedListsActionsAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordIds: [context.recordId],
-            },
-        };
-    }
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave({
-            ...request,
-            config: {
-                ...request.config,
-                recordIds: ['*'],
-            },
-        });
-    }
-    isContextDependent(context, request) {
-        const isForContext = request.config.recordIds &&
-            (context.recordId === request.config.recordIds || // some may set this as string instead of array
-                (request.config.recordIds.length === 1 &&
-                    request.config.recordIds[0] === context.recordId));
-        return isForContext && isReduceAbleRelatedListConfig(request.config);
-    }
-    /**
-     * Can only reduce two requests when they have the same recordId, and
-     * the individual relatedListAction config only have relatedListId.
-     *
-     * @param reqA
-     * @param reqB
-     * @returns boolean
-     */
-    canCombine(reqA, reqB) {
-        const [recordIdA, recordIdB] = [reqA.recordIds, reqB.recordIds].map((recordIds) => {
-            return isArray(recordIds)
-                ? recordIds.length === 1
-                    ? recordIds[0]
-                    : null
-                : recordIds;
-        });
-        return (recordIdA === recordIdB &&
-            recordIdA !== null &&
-            isReduceAbleRelatedListConfig(reqA) &&
-            isReduceAbleRelatedListConfig(reqB));
-    }
-    combineRequests(reqA, reqB) {
-        const relatedListsIncluded = new Set();
-        [reqA, reqB].forEach(({ relatedListsActionParameters }) => {
-            relatedListsActionParameters.forEach(({ relatedListId }) => relatedListsIncluded.add(relatedListId));
-        });
-        return {
-            recordIds: reqA.recordIds,
-            relatedListsActionParameters: from(relatedListsIncluded).map((relatedListId) => ({
-                relatedListId,
-            })),
-        };
-    }
-}
-
-const GET_RELATED_LIST_INFO_BATCH_ADAPTER_NAME = 'getRelatedListInfoBatch';
-class GetRelatedListInfoBatchRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RELATED_LIST_INFO_BATCH_ADAPTER_NAME;
-        this.adapterFactory = getRelatedListInfoBatchAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, _context) {
-        return similarRequest;
-    }
-    /**
-     * @override
-     */
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                parentObjectApiName: coerceObjectId(request.config.parentObjectApiName),
-            },
-        };
-    }
-    isContextDependent(context, request) {
-        // We have a higher degree of confidence of being able to use a similar request when
-        // optional config is not set AND the object type of the page context is the same as the
-        // object type related list is for.  This approach is based heavily with early predictions
-        // and the max of 12 aura requests in mind.  Same approach is taken in the single version of
-        // this request
-        return (context.objectApiName === request.config.parentObjectApiName &&
-            request.config.recordTypeId === undefined);
-    }
-    canCombine(reqA, reqB) {
-        return reqA.parentObjectApiName === reqB.parentObjectApiName;
-    }
-    combineRequests(reqA, reqB) {
-        const combined = { ...reqA };
-        combined.relatedListNames = Array.from(new Set([...reqA.relatedListNames, ...reqB.relatedListNames]));
-        return combined;
-    }
-}
-
-const GET_RELATED_LIST_INFO_ADAPTER_NAME = 'getRelatedListInfo';
-class GetRelatedListInfoRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RELATED_LIST_INFO_ADAPTER_NAME;
-        this.adapterFactory = getRelatedListInfoAdapterFactory;
-    }
-    /**
-     * @override
-     */
-    isContextDependent(context, request) {
-        // We have a higher degree of confidence of being able to use a similar request when
-        // optional config is not set AND the object type of the page context is the same as the
-        // object type related list is for.  This approach is based heavily with early predictions
-        // and the max of 12 aura requests in mind.  Same approach is taken in the batch version of
-        // this request
-        return (context.objectApiName === request.config.parentObjectApiName &&
-            this.isRequiredOnlyConfig(request.config));
-    }
-    /**
-     * @override
-     */
-    buildConcreteRequest(similarRequest, _context) {
-        return similarRequest;
-    }
-    /**
-     * @override
-     */
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                parentObjectApiName: coerceObjectId(request.config.parentObjectApiName),
-            },
-        };
-    }
-    /**
-     * For performance reasons (fear of over-fetching), we only want to predict single requests which either are not
-     * part of a batch request OR specify optional parameters (thus requiring data differing from that of a batch
-     * request).
-     *
-     * ADG currently handles the batching of getRelatedListInfo -> getRelatedListInfoBatch
-     * https://gitcore.soma.salesforce.com/core-2206/core-public/blob/p4/main/core/ui-laf-components/modules/laf/batchingPortable/reducers/RelatedListInfoBatchReducer.js
-     *
-     * @param unfilteredRequests
-     * @returns GetRelatedListInfoRequest[]
-     * @override
-     */
-    reduce(unfilteredRequests) {
-        // using batch versions of request, map keys of parent record to values of related lists
-        const batchRequests = unfilteredRequests.filter((entry) => entry.request.adapterName === GET_RELATED_LIST_INFO_BATCH_ADAPTER_NAME).reduce((result, entry) => {
-            // pull batch request parameters that correspond to single request parameters
-            const { parentObjectApiName, relatedListNames, recordTypeId } = entry.request.config;
-            // key based off of parent object and its type
-            const key = `${parentObjectApiName}_${recordTypeId}`;
-            // make sure an entry exists for the record
-            const relatedListIds = result.get(key) || new Set();
-            result.set(key, relatedListIds);
-            // add each related list to values for the record
-            relatedListNames.forEach((list) => relatedListIds.add(list));
-            return result;
-        }, new Map());
-        // return only the single requests that will NOT be covered by a batch request
-        return this.filterRequests(unfilteredRequests).filter((entry) => {
-            const config = entry.request.config;
-            if (!this.isRequiredOnlyConfig(config, true)) {
-                // requested data is customized beyond default; batch may not cover, so keep single request
-                return true;
-            }
-            // key based off of parent object and its type
-            const key = `${config.parentObjectApiName}_${config.recordTypeId}`;
-            // keep only the lists that are not batched
-            const batchLists = batchRequests.get(key);
-            return !(batchLists && batchLists.has(config.relatedListId));
-        });
-    }
-    /**
-     * Return true if the request config doesn't specify values for any of the optional parameters.
-     *
-     * @param config
-     * @param ignoreRecordType
-     */
-    isRequiredOnlyConfig(config, ignoreRecordType = false) {
-        return ((ignoreRecordType || config.recordTypeId === undefined) &&
-            (config.fields || []).length === 0 &&
-            (config.optionalFields || []).length === 0 &&
-            config.restrictColumnsToLayout !== false // default is true
-        );
-    }
-}
-
-// Copy-pasted from adapter-utils. This util should be extracted from generated code and imported in prefetch repository.
-/**
- * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
- * This is needed because insertion order for JSON.stringify(object) affects output:
- * JSON.stringify({a: 1, b: 2})
- *      "{"a":1,"b":2}"
- * JSON.stringify({b: 2, a: 1})
- *      "{"b":2,"a":1}"
- * @param data Data to be JSON-stringified.
- * @returns JSON.stringified value with consistent ordering of keys.
- */
-function stableJSONStringify(node) {
-    // This is for Date values.
-    if (node && node.toJSON && typeof node.toJSON === 'function') {
-        // eslint-disable-next-line no-param-reassign
-        node = node.toJSON();
-    }
-    if (node === undefined) {
-        return;
-    }
-    if (typeof node === 'number') {
-        return isFinite(node) ? '' + node : 'null';
-    }
-    if (typeof node !== 'object') {
-        return stringify$1(node);
-    }
-    let i;
-    let out;
-    if (isArray(node)) {
-        out = '[';
-        for (i = 0; i < node.length; i++) {
-            if (i) {
-                out += ',';
-            }
-            out += stableJSONStringify(node[i]) || 'null';
-        }
-        return out + ']';
-    }
-    if (node === null) {
-        return 'null';
-    }
-    const keys$1 = keys(node).sort();
-    out = '';
-    for (i = 0; i < keys$1.length; i++) {
-        const key = keys$1[i];
-        const value = stableJSONStringify(node[key]);
-        if (!value) {
-            continue;
-        }
-        if (out) {
-            out += ',';
-        }
-        out += stringify$1(key) + ':' + value;
-    }
-    return '{' + out + '}';
-}
-function isObject(obj) {
-    return obj !== null && typeof obj === 'object';
-}
-function deepEquals(objA, objB) {
-    if (objA === objB)
-        return true;
-    if (objA instanceof Date && objB instanceof Date)
-        return objA.getTime() === objB.getTime();
-    // If one of them is not an object, they are not deeply equal
-    if (!isObject(objA) || !isObject(objB))
-        return false;
-    // Filter out keys set as undefined, we can compare undefined as equals.
-    const keysA = keys(objA).filter((key) => objA[key] !== undefined);
-    const keysB = keys(objB).filter((key) => objB[key] !== undefined);
-    // If the objects do not have the same set of keys, they are not deeply equal
-    if (keysA.length !== keysB.length)
-        return false;
-    for (const key of keysA) {
-        const valA = objA[key];
-        const valB = objB[key];
-        const areObjects = isObject(valA) && isObject(valB);
-        // If both values are objects, recursively compare them
-        if (areObjects && !deepEquals(valA, valB))
-            return false;
-        // If only one value is an object or if the values are not strictly equal, they are not deeply equal
-        if (!areObjects && valA !== valB)
-            return false;
-    }
-    return true;
-}
-
-class PrefetchRepository {
-    constructor(storage, options = {}) {
-        this.storage = storage;
-        this.options = options;
-        this.requestBuffer = new Map();
-        this.pageStartTime = Date.now();
-    }
-    clearRequestBuffer() {
-        this.requestBuffer.clear();
-    }
-    markPageStart() {
-        this.pageStartTime = Date.now();
-    }
-    async flushRequestsToStorage() {
-        const setPromises = [];
-        for (const [id, batch] of this.requestBuffer) {
-            const page = { id, requests: [] };
-            batch.forEach(({ request, requestTime }) => {
-                const existingRequestEntry = page.requests.find(({ request: storedRequest }) => deepEquals(storedRequest, request));
-                if (existingRequestEntry === undefined) {
-                    page.requests.push({
-                        request,
-                        requestMetadata: {
-                            requestTime,
-                        },
-                    });
-                }
-                else if (requestTime < existingRequestEntry.requestMetadata.requestTime) {
-                    existingRequestEntry.requestMetadata.requestTime = requestTime;
-                }
-            });
-            const { modifyBeforeSaveHook, modifyPageBeforeSavingHook } = this.options;
-            if (modifyBeforeSaveHook !== undefined) {
-                page.requests = modifyBeforeSaveHook(page.requests);
-            }
-            if (modifyPageBeforeSavingHook !== undefined) {
-                modifyPageBeforeSavingHook(page);
-            }
-            setPromises.push(this.storage.set(id, page));
-        }
-        this.clearRequestBuffer();
-        await Promise.all(setPromises);
-    }
-    getKeyId(key) {
-        return stableJSONStringify(key);
-    }
-    saveRequest(key, request) {
-        const identifier = this.getKeyId(key);
-        const batchForKey = this.requestBuffer.get(identifier) || [];
-        batchForKey.push({
-            request,
-            requestTime: Date.now() - this.pageStartTime,
-        });
-        this.requestBuffer.set(identifier, batchForKey);
-    }
-    getPage(key) {
-        const identifier = this.getKeyId(key);
-        return this.storage.get(identifier);
-    }
-    getPageRequests(key) {
-        if (!key) {
-            return [];
-        }
-        const page = this.getPage(key);
-        if (page === undefined) {
-            return [];
-        }
-        return page.requests;
-    }
-}
-
-const GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME = 'getRelatedListRecordsBatch';
-class GetRelatedListRecordsBatchRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME;
-        this.adapterFactory = getRelatedListRecordsBatchAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                parentRecordId: context.recordId,
-            },
-        };
-    }
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave({
-            ...request,
-            config: {
-                ...request.config,
-                parentRecordId: '*',
-            },
-        });
-    }
-    isContextDependent(context, request) {
-        return context.recordId === request.config.parentRecordId;
-    }
-    /**
-     * Can combine two seperate batch requests if the parentRecordId is the same.
-     * @param reqA The first GetRelatedListRecordsBatchConfig.
-     * @param reqB The first GetRelatedListRecordsBatchConfig.
-     * @returns true if the requests can be combined, otherwise false.
-     */
-    canCombine(reqA, reqB) {
-        return reqA.parentRecordId === reqB.parentRecordId;
-    }
-    /**
-     * Merge the relatedListParameters together between two combinable batch requests.
-     * @param reqA The first GetRelatedListRecordsBatchConfig.
-     * @param reqB The first GetRelatedListRecordsBatchConfig.
-     * @returns The combined request.
-     */
-    combineRequests(reqA, reqB) {
-        const relatedListParametersMap = new Set(reqA.relatedListParameters.map((relatedListParameter) => {
-            return stableJSONStringify(relatedListParameter);
-        }));
-        const reqBRelatedListParametersToAdd = reqB.relatedListParameters.filter((relatedListParameter) => {
-            return !relatedListParametersMap.has(stableJSONStringify(relatedListParameter));
-        });
-        reqA.relatedListParameters = reqA.relatedListParameters.concat(reqBRelatedListParametersToAdd);
-        return reqA;
-    }
-}
-
-const GET_RELATED_LIST_RECORDS_ADAPTER_NAME = 'getRelatedListRecords';
-class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RELATED_LIST_RECORDS_ADAPTER_NAME;
-        this.adapterFactory = getRelatedListRecordsAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                parentRecordId: context.recordId,
-            },
-        };
-    }
-    /**
-     *
-     * This method returns GetRelatedListRecordsRequest[] that won't be part of a batch request.
-     *
-     * ADG currently handles the batching of GetRelatedListRecords -> GetRelatedListRecordsBatch
-     * https://gitcore.soma.salesforce.com/core-2206/core-public/blob/p4/main/core/ui-laf-components/modules/laf/batchingPortable/reducers/RelatedListRecordsBatchReducer.js
-     *
-     * For performance reasons (fear to overfetch), we only check that the Single relatedListId is not present in any of the Batch requests,
-     * but we don't check for any other parameters.
-     *
-     * @param unfilteredRequests All of the request available for predictions.
-     * @returns GetRelatedListRecordsRequest[] That should be a prediction.
-     */
-    reduce(unfilteredRequests) {
-        // Batch requests by [parentRecordId]->[RelatedListIds]
-        const batchRequests = unfilteredRequests.filter((entry) => entry.request.adapterName === GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME).reduce((acc, entry) => {
-            // required properties, enforced by adapter typecheck
-            const { parentRecordId, relatedListParameters } = entry.request.config;
-            const existingRlSet = acc.get(parentRecordId) || new Set();
-            // relatedListId enforced by adapter typecheck
-            relatedListParameters.forEach((rlParam) => existingRlSet.add(rlParam.relatedListId));
-            acc.set(parentRecordId, existingRlSet);
-            return acc;
-        }, new Map());
-        const singleRequests = unfilteredRequests.filter((entry) => entry.request.adapterName === this.adapterName);
-        return singleRequests.filter((entry) => {
-            // required props enforced by adapter typecheck
-            const { parentRecordId, relatedListId } = entry.request.config;
-            const batchForParentRecordId = batchRequests.get(parentRecordId);
-            return !(batchForParentRecordId && batchForParentRecordId.has(relatedListId));
-        });
-    }
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave({
-            ...request,
-            config: {
-                ...request.config,
-                parentRecordId: '*',
-            },
-        });
-    }
-    isContextDependent(context, request) {
-        return context.recordId === request.config.parentRecordId;
-    }
-}
-
-const APEX_RESOURCE_CONTEXT = {
-    ...DEFAULT_RESOURCE_CONTEXT,
-    sourceContext: {
-        ...DEFAULT_RESOURCE_CONTEXT.sourceContext,
-        // We don't want to override anything for Apex, it is not part
-        // of UiApi, and it can cause undesired behavior.
-        actionConfig: undefined,
-    },
-};
-function getApexPdlFactory(luvio) {
-    return ({ invokerParams, config }, requestContext) => {
-        return GetApexWireAdapterFactory(luvio, invokerParams)(config, requestContext);
-    };
-}
-const GET_APEX_ADAPTER_NAME = 'getApex';
-class GetApexRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_APEX_ADAPTER_NAME;
-        this.adapterFactory = getApexPdlFactory;
-    }
-    buildConcreteRequest(similarRequest) {
-        return similarRequest;
-    }
-    createAdapterContext(_options) {
-        return APEX_RESOURCE_CONTEXT;
-    }
-    getRequestPriority(_request, _context) {
-        return 0 /* RequestPriority.LOW */;
-    }
-}
-
-const GET_LIST_INFO_BY_NAME_ADAPTER_NAME = 'getListInfoByName';
-class GetListInfoByNameRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_LIST_INFO_BY_NAME_ADAPTER_NAME;
-        this.adapterFactory = getListInfoByNameAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest) {
-        return similarRequest;
-    }
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                // (!): if we are saving this request is because the adapter already verified is valid.
-                objectApiName: coerceObjectId(request.config.objectApiName),
-            },
-        };
-    }
-    canCombine(reqA, reqB) {
-        return (reqA.objectApiName === reqB.objectApiName &&
-            reqA.listViewApiName === reqB.listViewApiName);
-    }
-    combineRequests(reqA, _reqB) {
-        return reqA;
-    }
-}
-
-const GET_LIST_INFOS_BY_OBJECT_NAME_ADAPTER_NAME = 'getListInfosByObjectName';
-class GetListInfosByObjectNameRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_LIST_INFOS_BY_OBJECT_NAME_ADAPTER_NAME;
-        this.adapterFactory = getListInfosByObjectNameAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest) {
-        return similarRequest;
-    }
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                // (!): if we are saving this request is because the adapter already verified is valid.
-                objectApiName: coerceObjectId(request.config.objectApiName),
-            },
-        };
-    }
-    canCombine(reqA, reqB) {
-        return (reqA.objectApiName === reqB.objectApiName &&
-            reqA.q === reqB.q &&
-            reqA.recentListsOnly === reqB.recentListsOnly &&
-            reqA.pageSize === reqB.pageSize);
-    }
-    combineRequests(reqA, _reqB) {
-        return reqA;
-    }
-}
-
-const GET_LIST_RECORDS_BY_NAME_ADAPTER_NAME = 'getListRecordsByName';
-function arrEq(array1, array2) {
-    if (array1.length !== array2.length) {
-        return false;
-    }
-    const sortedArray1 = [...array1].sort();
-    const sortedArray2 = [...array2].sort();
-    return sortedArray1.every((value, index) => value === sortedArray2[index]);
-}
-class GetListRecordsByNameRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_LIST_RECORDS_BY_NAME_ADAPTER_NAME;
-        this.adapterFactory = getListRecordsByNameAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest) {
-        return similarRequest;
-    }
-    transformForSave(request) {
-        // No longer combining fields and optionalFields due to issue W-17353101
-        return request;
-    }
-    canCombine(reqA, reqB) {
-        return (reqA.objectApiName === reqB.objectApiName &&
-            reqA.listViewApiName === reqB.listViewApiName &&
-            reqA.pageSize === reqB.pageSize &&
-            reqA.searchTerm === reqB.searchTerm &&
-            reqA.sortBy === reqB.sortBy &&
-            reqA.where === reqB.where &&
-            arrEq(reqA.fields || [], reqB.fields || []) &&
-            arrEq(reqB.optionalFields || [], reqB.optionalFields || []));
-    }
-    combineRequests(reqA, _reqB) {
-        return reqA;
-    }
-}
-
-const GET_LIST_OBJECT_INFO_ADAPTER_NAME = 'getListObjectInfo';
-class GetListObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_LIST_OBJECT_INFO_ADAPTER_NAME;
-        this.adapterFactory = getListObjectInfoAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest) {
-        return similarRequest;
-    }
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                // (!): if we are saving this request is because the adapter already verified is valid.
-                objectApiName: coerceObjectId(request.config.objectApiName),
-            },
-        };
-    }
-    canCombine(reqA, reqB) {
-        return reqA.objectApiName === reqB.objectApiName;
-    }
-    combineRequests(reqA, _reqB) {
-        return reqA;
-    }
-}
-
-const GET_RELATED_LISTS_INFO_ADAPTER_NAME = 'getRelatedListsInfo';
-class GetRelatedListsInfoRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RELATED_LISTS_INFO_ADAPTER_NAME;
-        this.adapterFactory = getRelatedListsInfoAdapterFactory;
-    }
-    /**
-     * @override
-     */
-    isContextDependent(context, request) {
-        return (context.objectApiName === coerceObjectId(request.config.parentObjectApiName) &&
-            context.recordTypeId === request.config.recordTypeId);
-    }
-    /**
-     * @override
-     */
-    buildConcreteRequest(similarRequest, _context) {
-        return similarRequest;
-    }
-    /**
-     * @override
-     */
-    transformForSave(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                parentObjectApiName: coerceObjectId(request.config.parentObjectApiName),
-            },
-        };
-    }
-    canCombine(reqA, reqB) {
-        // only combine if both requests are equal.
-        return (reqA.parentObjectApiName === reqB.parentObjectApiName &&
-            reqA.recordTypeId === reqB.recordTypeId);
-    }
-    combineRequests(reqA, _reqB) {
-        return reqA;
-    }
-}
-
-const GET_RELATED_LIST_ACTIONS_ADAPTER_NAME = 'getRelatedListActions';
-/**
- * Returns true if the config is only the required configuration.
- *
- * @param config - The related list actions config
- * @returns boolean - true if the config is only the required configuration
- */
-function isRequiredOnlyConfig(config) {
-    return (config.apiNames === undefined &&
-        config.actionTypes === undefined &&
-        config.formFactor === undefined &&
-        config.retrievalMode === undefined &&
-        config.sections === undefined);
-}
-class GetRelatedListActionsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = GET_RELATED_LIST_ACTIONS_ADAPTER_NAME;
-        this.adapterFactory = getRelatedListActionsAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordIds: [context.recordId],
-            },
-        };
-    }
-    transformForSave(request) {
-        // we only need to coerce the required configuration because only those fields are
-        // manipulated by the strategy.
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                // (!): if is recorded in PDL, it was already validated by the adapter.
-                recordIds: getRecordId18Array(request.config.recordIds) || [],
-            },
-        };
-    }
-    transformForSaveSimilarRequest(request) {
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                recordIds: ['*'],
-            },
-        };
-    }
-    isContextDependent(context, { config }) {
-        // Note: despite recordIds being an array, it is common to send just one recordId as a string.
-        //       Also, recordIds is a required param, and the factory would have failed if recordIds is missing,
-        //       normalizing to an empty array to avoid an error from PDL if that logic fails.
-        const requestRecordsIds = getRecordId18Array(config.recordIds) || [];
-        const configHasOnlyOneRecord = requestRecordsIds.length === 1;
-        return (configHasOnlyOneRecord &&
-            requestRecordsIds[0] === context.recordId &&
-            isRequiredOnlyConfig(config));
-    }
-    canCombine(reqA, reqB) {
-        // At the moment, these are not combinable by this strategy, except when they are the same request
-        return (isRequiredOnlyConfig(reqA) &&
-            isRequiredOnlyConfig(reqB) &&
-            reqA.recordIds.length === 1 &&
-            reqB.recordIds.length === 1 &&
-            reqA.recordIds[0] === reqB.recordIds[0] &&
-            reqA.relatedListId === reqB.relatedListId);
-    }
-    combineRequests(reqA, _reqB) {
-        // both request are the same, return only one of them.
-        return reqA;
-    }
-}
-
-/**
- * Base implementation of a home page
- */
-class AbstractHomePage extends LexDefaultPage {
-    constructor(context, similarContext, requestStrategyManager, supportedAdapters) {
-        super(context, similarContext);
-        this.requestStrategyManager = requestStrategyManager;
-        this.supportedAdapters = supportedAdapters;
-    }
-    supportsRequest(request) {
-        return this.supportedAdapters.has(request.adapterName);
-    }
-    buildSaveRequestData(request) {
-        const requestBuckets = [];
-        const { adapterName } = request;
-        const matchingRequestStrategy = this.requestStrategyManager.get(adapterName);
-        if (matchingRequestStrategy === undefined) {
-            return [];
-        }
-        if (matchingRequestStrategy.isContextDependent(this.context, request)) {
-            requestBuckets.push({
-                key: this.getSimilarKey(),
-                request: matchingRequestStrategy.transformForSaveSimilarRequest(request, this.context),
-            });
-        }
-        else {
-            requestBuckets.push({
-                key: this.getExactKey(),
-                request: matchingRequestStrategy.transformForSave(request, this.context),
-            });
-        }
-        return requestBuckets;
-    }
-}
-
-const RECORD_HOME_SUPPORTED_ADAPTERS = new Set([
-    GET_APEX_ADAPTER_NAME,
-    GET_OBJECT_INFO_ADAPTER_NAME,
-    GET_OBJECT_INFO_BATCH_ADAPTER_NAME,
-    GET_RECORD_ACTIONS_ADAPTER_NAME,
-    GET_RECORD_AVATARS_ADAPTER_NAME,
-    GET_RECORD_ADAPTER_NAME,
-    GET_RECORDS_ADAPTER_NAME,
-    GET_RELATED_LIST_INFO_BATCH_ADAPTER_NAME,
-    GET_RELATED_LIST_INFO_ADAPTER_NAME,
-    GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME,
-    GET_RELATED_LIST_RECORDS_ADAPTER_NAME,
-    GET_RELATED_LISTS_ACTIONS_ADAPTER_NAME,
-    GET_RELATED_LISTS_INFO_ADAPTER_NAME,
-    GET_RELATED_LIST_ACTIONS_ADAPTER_NAME,
-    'templateApi',
-    'Aura.getComponentsDef', // external - Predictive Loading for CMP Definitions
-]);
-class RecordHomePage extends AbstractHomePage {
-    constructor(context, requestStrategyManager) {
-        super(context, {
-            ...context,
-            recordId: '*',
-        }, requestStrategyManager, RECORD_HOME_SUPPORTED_ADAPTERS);
-    }
-    getExactKey() {
-        return RecordHomePage.contextToExactKey(this.context);
-    }
-    resolveSimilarRequest(similarRequest) {
-        const { adapterName } = similarRequest;
-        const matchingRequestStrategy = this.requestStrategyManager.get(adapterName);
-        if (matchingRequestStrategy === undefined) {
-            return similarRequest;
-        }
-        return matchingRequestStrategy.buildConcreteRequest(similarRequest, this.context);
-    }
-    // Record Home performs best when we always do a minimal getRecord alongside the other requests.
-    // The reason is that the Highlights and Detail panel will always request the recordTypeId first.
-    // https://sourcegraph.soma.salesforce.com/perforce.soma.salesforce.com/app/main/core/-/blob/ui-laf-components/modules/laf/templateApi/getRecordLayoutTemplate.js?L24
-    getAlwaysRunRequests() {
-        const { recordId, objectApiName } = this.context;
-        return [
-            {
-                adapterName: 'getRecord',
-                config: {
-                    recordId,
-                    optionalFields: [`${objectApiName}.Id`, `${objectApiName}.RecordTypeId`],
-                },
-            },
-        ];
-    }
-    /**
-     * In RH, we should execute the getRecord(id, type) by itself as we want the result asap, so
-     * it does not stop rendering.
-     * @returns true
-     */
-    shouldExecuteAlwaysRequestByThemself() {
-        return true;
-    }
-    static handlesContext(context) {
-        return (context !== undefined &&
-            context.actionName !== undefined &&
-            context.objectApiName !== undefined &&
-            context.recordId !== undefined &&
-            context.type === 'recordPage');
-    }
-    static contextToExactKey(context) {
-        const { recordTypeId: _, ...key } = context;
-        return key;
-    }
-}
-
-const OBJECT_HOME_SUPPORTED_ADAPTERS = new Set([
-    GET_LIST_INFO_BY_NAME_ADAPTER_NAME,
-    GET_LIST_OBJECT_INFO_ADAPTER_NAME,
-    GET_LIST_RECORDS_BY_NAME_ADAPTER_NAME,
-    GET_LIST_INFOS_BY_OBJECT_NAME_ADAPTER_NAME,
-    GET_OBJECT_INFO_BATCH_ADAPTER_NAME,
-]);
-class ObjectHomePage extends AbstractHomePage {
-    constructor(context, requestStrategyManager) {
-        super(context, context, requestStrategyManager, OBJECT_HOME_SUPPORTED_ADAPTERS);
-    }
-    // these are requests that run always regardless of any other request existing
-    getAlwaysRunRequests() {
-        const { listViewApiName, objectApiName } = this.context;
-        return [
-            {
-                adapterName: 'getListInfoByName',
-                config: {
-                    objectApiName: objectApiName,
-                    listViewApiName: listViewApiName,
-                },
-            },
-            {
-                adapterName: 'getListInfosByObjectName',
-                config: {
-                    objectApiName: objectApiName,
-                    pageSize: 100,
-                    q: '',
-                },
-            },
-            {
-                adapterName: 'getListInfosByObjectName',
-                config: {
-                    objectApiName: objectApiName,
-                    pageSize: 10,
-                    recentListsOnly: true,
-                },
-            },
-            {
-                adapterName: 'getListObjectInfo',
-                config: {
-                    objectApiName: objectApiName,
-                },
-            },
-        ];
-    }
-    /**
-     * In OH, the always requests are reduced with predictions, and because they
-     * can't be merged with other predictions, they will always run by themself.
-     * This value must be `false`, otherwise we may see repeated requests.
-     *
-     * @returns false
-     */
-    shouldExecuteAlwaysRequestByThemself() {
-        return false;
-    }
-    // Identifies a valid ObjectHomeContext
-    static handlesContext(context) {
-        return (context !== undefined &&
-            context.listViewApiName !== undefined &&
-            context.objectApiName !== undefined &&
-            context.type === 'objectHomePage');
-    }
-}
-
-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, eventEmitter) {
-        this.repository = repository;
-        this.requestRunner = requestRunner;
-        this.eventEmitter = eventEmitter;
-        this.isRecording = false;
-        this.totalRequestCount = 0;
-        this.queuedPredictionRequests = [];
-        this._context = context;
-        this.page = this.getPage();
-    }
-    set context(value) {
-        this._context = value;
-        this.page = this.getPage();
-    }
-    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) {
-            return;
-        }
-        executeAsyncActivity(METRIC_KEYS.PREDICTIVE_DATA_LOADING_SAVE_REQUEST, (_act) => {
-            if (this.page.supportsRequest(request)) {
-                const saveBuckets = this.page.buildSaveRequestData(request);
-                saveBuckets.forEach((saveBucket) => {
-                    const { request: requestToSave, key } = saveBucket;
-                    // No need to differentiate from predictions requests because these
-                    // are made from the adapters factory, which are not prediction aware.
-                    this.repository.saveRequest(key, requestToSave);
-                });
-            }
-            return Promise.resolve().then();
-        }, PDL_EXECUTE_ASYNC_OPTIONS);
-    }
-    async predict() {
-        const alwaysRequests = this.page.getAlwaysRunRequests();
-        const similarPageRequests = this.getSimilarPageRequests();
-        const exactPageRequests = this.getExactPageRequests();
-        // Always requests can't be reduced in - Some of them are essential to keep the page rendering at the beginning.
-        const reducedRequests = this.requestRunner
-            .reduceRequests([...exactPageRequests, ...similarPageRequests])
-            .map((entry) => entry.request);
-        const predictedRequests = [...alwaysRequests, ...reducedRequests];
-        this.queuedPredictionRequests.push(...predictedRequests);
-        this.totalRequestCount = predictedRequests.length;
-        return Promise.all(predictedRequests.map((request) => this.requestRunner.runRequest(request))).then();
-    }
-    getPredictionSummary() {
-        return {
-            exact: this.getExactPageRequests().length,
-            similar: this.getSimilarPageRequests().length,
-            totalRequestCount: this.totalRequestCount,
-        };
-    }
-    hasPredictions() {
-        const summary = this.getPredictionSummary();
-        return summary.exact > 0 || summary.similar > 0;
-    }
-    getSimilarPageRequests() {
-        return this.repository.getPageRequests(this.page.getSimilarKey()).map((entry) => {
-            return {
-                ...entry,
-                request: this.page.resolveSimilarRequest(entry.request),
-            };
-        });
-    }
-    getExactPageRequests() {
-        return this.repository.getPageRequests(this.page.getExactKey()) || [];
-    }
-}
-
-/**
- * Runs a list of requests with a specified concurrency limit.
- *
- * @template Request - The type of the requests being processed.
- * @param {RequestEntry<Request>[]} requests - An array of request entries to be processed in the array order.
- * @param {RequestRunner<Request>} runner - The runner instance responsible for executing the requests.
- * @param {number} concurrentRequestsLimit - The maximum number of concurrent requests allowed.
- * @param {number} pageStartTime - The start time of the page load, used to calculate the time elapsed since the page starts loading.
- * @returns {Promise<void>} A promise that resolves when all requests have been processed.
- *
- * This function manages a queue of pending requests and processes them with a concurrency limit.
- * Requests are only processed if their `requestTime` is less than the time elapsed since `pageStartTime`.
- */
-async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, pageStartTime) {
-    // queue for pending prediction requests
-    const requestQueue = [...requests];
-    // Function to process the next request in the queue
-    const processNextRequest = async (verifyPastTime = true) => {
-        const timeInWaterfall = Date.now() - pageStartTime;
-        while (requestQueue.length > 0 &&
-            verifyPastTime &&
-            requestQueue[0].requestMetadata.requestTime <= timeInWaterfall) {
-            requestQueue.shift();
-        }
-        if (requestQueue.length > 0) {
-            // (!) requestQueue will always have at least one element ensured by the above check.
-            const nextRequest = requestQueue.shift();
-            try {
-                // Run the request and wait for it to complete
-                await runner.runRequest(nextRequest.request);
-            }
-            finally {
-                await processNextRequest();
-            }
-        }
-    };
-    // Start processing requests up to concurrentRequestsLimit
-    const initialRequests = Math.min(concurrentRequestsLimit, requestQueue.length);
-    const promises = [];
-    for (let i = 0; i < initialRequests; i++) {
-        // Initial requests should always execute, without verifying if they are past due.
-        // Reasoning:
-        //   It may be that one of the alwaysRequest (with 0 as start time) that is reduced
-        //   with the regular requests to make these to have 0 as the initial time in the waterfall.
-        //   Because predictions are behind an await (see W-16139321), it could be that when this code is evaluated
-        //   is already past time for the request.
-        promises.push(processNextRequest(false));
-    }
-    // Wait for all initial requests to complete
-    await Promise.all(promises);
-}
-/**
- * Runs entire list of LEX requests, applying hotspot up to the specified limit and disabling for all remaining
- *
- * @param {RequestEntry<LexRequest>[]} requests - An array of request entries to be processed in the array order.
- * @param {RequestRunner<LexRequest, LexRequestOptions>} runner - The runner instance responsible for executing the requests.
- * @param {number} hotspotLimit - The number of hotspot requests allowed.
- * @returns {Promise<void>} A promise that resolves when all requests have been processed.
- *
- * This function processes a queue of pending requests, enabling hotspot for the first N requests,
- * as specified by the hotspotLimit argument.  The remaining requests have hotspot disabled.
- */
-async function runRequestsWithHotspotLimit(requests, runner, hotspotLimit) {
-    const promises = requests.map((request, index) => {
-        // determine if hotspot needs to be disabled or not
-        const disableHotspot = index >= hotspotLimit;
-        // run request with hotspot setting
-        return runner.runRequest(request.request, { disableHotspot });
-    });
-    // promise for all requests
-    await Promise.all(promises);
-}
-/**
- * Compares two request entries based on their priority and, if the priorities are the same, their request times.
- * This function is typically used for sorting requests where priority takes precedence, and timing is used
- * as a secondary criterion. The function assumes that any necessary filtering of requests has already been done.
- *
- * @template Context - Extends `DefaultPageContext`, provides additional context for the request priority determination.
- *
- * @param {RequestEntry<LexRequest>} requestA - The first request entry containing the request and its metadata.
- * @param {RequestEntry<LexRequest>} requestB - The second request entry containing the request and its metadata.
- * @param {RequestStrategyManager} requestStrategyManager - Manager that provides access to request strategies based on adapter names.
- * @param {Context} context - The context in which the requests are being compared, used to determine request priority.
- *
- * @returns {number} A negative number if the first request should come before the second, a positive number if the
- *                   second should come before the first, or zero if they are considered equal for sorting purposes.
- *                   This is determined first by the priority (higher priority comes first) and then by the request
- *                   time (earlier request comes first) if priorities are the same. The priorities are fetched from
- *                   the `requestStrategyManager` for each request's `adapterName`. If a strategy is not found,
- *                   the priority defaults to `RequestPriority.LOW`.
- */
-function compareByPriorityThenTime({ request: requestA, requestMetadata: requestMetadataA }, { request: requestB, requestMetadata: requestMetadataB }, requestStrategyManager, context) {
-    const aPriority = requestStrategyManager.get(requestA.adapterName)?.getRequestPriority(requestA, context) ||
-        0 /* RequestPriority.LOW */;
-    const bPriority = requestStrategyManager.get(requestB.adapterName)?.getRequestPriority(requestB, context) ||
-        0 /* RequestPriority.LOW */;
-    if (aPriority === bPriority) {
-        // when both requests have the same priority, use the request time in waterfall.
-        return requestMetadataA.requestTime - requestMetadataB.requestTime;
-    }
-    else {
-        // sort by priority, descending
-        return bPriority - aPriority;
-    }
-}
-/**
- * Returns the value of the gate that controls whether to use the hotspot limit.  Value is cached after the initial call
- *
- * @returns {boolean} true if the gate is open, false otherwise.
- */
-let useHotspotLimitOpen;
-function isUseHotspotLimitOpen() {
-    useHotspotLimitOpen = useHotspotLimitOpen ?? useHotspotLimit.isOpen({ fallback: false });
-    return useHotspotLimitOpen;
-}
-
-function isBoxcarableRequest({ request: { adapterName } }, requestStrategyManager) {
-    const strategy = requestStrategyManager.get(adapterName);
-    return strategy === undefined || strategy.isBoxcarable;
-}
-function predictNonBoxcarableRequest(nonBoxcaredPredictions, requestRunner) {
-    const reducedPredictions = requestRunner.reduceRequests(nonBoxcaredPredictions);
-    reducedPredictions.map((request) => requestRunner.runRequest(request.request));
-}
-const DEFAULT_RECORD_TYPE_ID = '012000000000000AAA';
-const AURA_BOXCAR_THREADS_THRESHOLD = 3;
-class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
-    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, eventEmitter);
-        this.options = options;
-        this.requestStrategyManager = requestStrategyManager;
-        this.page = this.getPage();
-    }
-    getPage() {
-        if (RecordHomePage.handlesContext(this.context)) {
-            /*
-             * `recordTypeId` is required in order to create similar request keys.  However, the means by which it is
-             * obtained varies based on when in the app lifecycle predictions are requested.
-             */
-            // check context for record type
-            if (!this.context.recordTypeId) {
-                // don't have it (i.e., early predictions), so need try to obtain via exact matches
-                const exact = this.repository.getPage(RecordHomePage.contextToExactKey(this.context));
-                // use found recordTypeId, otherwise fallback to default
-                this.context.recordTypeId = (exact && exact.recordTypeId) || DEFAULT_RECORD_TYPE_ID;
-            }
-            return new RecordHomePage(this.context, this.requestStrategyManager);
-        }
-        else if (ObjectHomePage.handlesContext(this.context)) {
-            return new ObjectHomePage(this.context, this.requestStrategyManager);
-        }
-        return new LexDefaultPage(this.context);
-    }
-    getAllPageRequests() {
-        const exactPageRequests = this.getExactPageRequests();
-        const similarPageRequests = this.getSimilarPageRequests();
-        return [...exactPageRequests, ...similarPageRequests];
-    }
-    getPredictedRequestsOrderedByPriority() {
-        // perf: caching access, to avoid this.prop in loops.
-        const { requestStrategyManager, context } = this;
-        const alwaysRequests = this.page.getAlwaysRunRequests();
-        const pageRequests = this.getAllPageRequests();
-        // IMPORTANT: Because there's no way to differentiate a cmpDef prediction from the page
-        //            requesting the cmpDef, we need to predict cmpDefs before we start watching
-        //            for predictions in the page. Having this code after an
-        //            await will make the predictions to be saved as predictions too.
-        predictNonBoxcarableRequest(pageRequests.filter((r) => !isBoxcarableRequest(r, requestStrategyManager)), this.requestRunner);
-        const alwaysRequestEntries = alwaysRequests.map((request) => {
-            return {
-                request,
-                requestMetadata: { requestTime: 0 }, // ensures always requests are executed, and executed first.
-            };
-        });
-        const boxcarablePredictions = pageRequests.filter((r) => isBoxcarableRequest(r, requestStrategyManager));
-        const reducedPredictions = this.page.shouldReduceAlwaysRequestsWithPredictions()
-            ? this.requestRunner.reduceRequests([...boxcarablePredictions, ...alwaysRequestEntries])
-            : this.requestRunner.reduceRequests(boxcarablePredictions);
-        // Sorting in order requested
-        reducedPredictions.sort((a, b) => compareByPriorityThenTime(a, b, requestStrategyManager, context));
-        // When available, alwaysRequestEntries are prioritized.
-        return this.page.shouldExecuteAlwaysRequestByThemself()
-            ? [...alwaysRequestEntries, ...reducedPredictions]
-            : reducedPredictions;
-    }
-    async predict() {
-        const requests = this.getPredictedRequestsOrderedByPriority();
-        this.totalRequestCount = requests.length;
-        if (isUseHotspotLimitOpen()) {
-            await runRequestsWithHotspotLimit(requests, this.requestRunner, Math.floor(this.options.inflightRequestLimit / 2));
-        }
-        else {
-            await runRequestsWithLimit(requests, this.requestRunner, 
-            // don't get available thread count below threshold else Aura will boxcar
-            this.options.inflightRequestLimit - AURA_BOXCAR_THREADS_THRESHOLD, 
-            // `this.repository.pageStartTime` would be the correct here,
-            // but when doing predict+watch, it could be (set in watch)
-            // repository.startTime is not set yet, Date.now() is a better alternative,
-            // that is correct, and works on both cases.
-            Date.now());
-        }
-    }
-}
-
-class LexRequestRunner {
-    constructor(requestStrategyManager) {
-        this.requestStrategyManager = requestStrategyManager;
-        this.requestStrategyManager = requestStrategyManager;
-    }
-    reduceRequests(requests) {
-        return this.requestStrategyManager
-            .getAll()
-            .map((strategy) => strategy.reduce(requests))
-            .flat();
-    }
-    runRequest(request, options = {}) {
-        const strategy = this.requestStrategyManager.get(request.adapterName);
-        if (strategy) {
-            return Promise.resolve(strategy.execute(request.config, options)).then();
-        }
-        return Promise.resolve(undefined);
-    }
-}
-
-class InMemoryPrefetchStorage {
-    constructor() {
-        this.data = {};
-    }
-    set(key, value) {
-        this.data[key] = value;
-        return Promise.resolve();
-    }
-    get(key) {
-        return this.data[key];
-    }
-}
-
-const DEFAULT_STORAGE_OPTIONS = {
-    name: 'ldsPredictiveLoading',
-    persistent: true,
-    secure: true,
-    maxSize: 7 * 1024 * 1024,
-    expiration: 5 * 24 * 60 * 60,
-    clearOnInit: false,
-    debugLogging: false,
-    version: 3,
-};
-function buildAuraPrefetchStorage(options = {}) {
-    const { onPredictionsReadyCallback, ...storageOptions } = options;
-    const auraStorage = createStorage({
-        ...DEFAULT_STORAGE_OPTIONS,
-        ...storageOptions,
-    });
-    const inMemoryStorage = new InMemoryPrefetchStorage();
-    if (auraStorage === null) {
-        return inMemoryStorage;
-    }
-    return new AuraPrefetchStorage(auraStorage, inMemoryStorage, onPredictionsReadyCallback);
-}
-function buildAuraLocalStoragePrefetchStorage(options = {}) {
-    const { onPredictionsReadyCallback, ...storageOptions } = options;
-    const auraStorage = createStorage({
-        ...DEFAULT_STORAGE_OPTIONS,
-        ...storageOptions,
-        secure: false,
-        adapterType: 'localstorage',
-        name: 'pdl',
-        maxSize: 4096000, // 4MB
-    });
-    if (auraStorage === null) {
-        return buildAuraPrefetchStorage(options);
-    }
-    const inMemoryStorage = new InMemoryPrefetchStorage();
-    return new AuraPrefetchStorage(auraStorage, inMemoryStorage, onPredictionsReadyCallback);
-}
-class AuraPrefetchStorage {
-    constructor(auraStorage, inMemoryStorage, onPredictionsReadyCallback = () => { }) {
-        this.auraStorage = auraStorage;
-        this.inMemoryStorage = inMemoryStorage;
-        /**
-         * Because of aura is an event loop hog and we therefore need to minimize asynchronicity in LEX,
-         * we need need to preload predictions and treat read operations sync. Not making it sync, will cause
-         * some request to be sent the network when they could be dedupe against those from the predictions.
-         *
-         * Drawbacks of this approach:
-         * 1. Loading all of aura storage into memory and then updating it based on changes to that in memory
-         *    representation means that updates to predictions in aura storage across different tabs will result
-         *    in overwrites, not graceful merges of predictions.
-         * 2. If whoever is consuming this tries to get and run predictions before this is done loading,
-         *    then they will (potentially incorrectly) think that we don't have any predictions.
-         */
-        auraStorage.getAll().then((results) => {
-            keys(results).forEach((key) => this.inMemoryStorage.set(key, results[key]));
-            onPredictionsReadyCallback();
-        });
-    }
-    set(key, value) {
-        const inMemoryResult = this.inMemoryStorage.set(key, value);
-        this.auraStorage.set(key, value).catch((error) => {
-            if (process.env.NODE_ENV !== 'production') {
-                // eslint-disable-next-line no-console
-                console.error('Error save LDS prediction: ', error);
-            }
-        });
-        return inMemoryResult;
-    }
-    get(key) {
-        // we never read from the AuraStorage, except in construction.
-        return this.inMemoryStorage.get(key);
-    }
-}
-
-function isLocalStorageAvailable() {
-    try {
-        const testKey = 'test';
-        window.localStorage.setItem(testKey, '1');
-        window.localStorage.removeItem(testKey);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-}
-function buildPrefetchStorage(useLocalStorage, options) {
-    if (useLocalStorage && isLocalStorageAvailable()) {
-        return buildAuraLocalStoragePrefetchStorage(options);
-    }
-    else {
-        return buildAuraPrefetchStorage(options);
-    }
-}
-
-class NoComposedAdapterTypeError extends TypeError {
-    constructor(message, resourceRequest) {
-        super(message);
-        this.resourceRequest = resourceRequest;
-    }
-}
-
-function buildComposableNetworkAdapter(composedAdapters) {
-    return (resourceRequest, resourceRequestContext) => {
-        const composedAdapter = composedAdapters.find((adapter) => adapter.shouldHandleRequest(resourceRequest));
-        if (composedAdapter === undefined) {
-            throw new NoComposedAdapterTypeError('There are no network adapters that can process the request.', resourceRequest);
-        }
-        return composedAdapter.adapter(resourceRequest, resourceRequestContext);
-    };
-}
-
-function getComposedAdapters() {
-    const composedAdapters = [
-        composedNetworkAdapter$1, // SFAP adapter
-    ];
-    // Add the UIAPI Fetch adapter if any of its API paths are enabled
-    if (isFetchAdapterEnabled()) {
-        composedAdapters.push(composedFetchNetworkAdapter); // UIAPI Fetch adapter
-    }
-    return composedAdapters;
-}
-const composedNetworkAdapter = buildComposableNetworkAdapter([
-    ...getComposedAdapters(),
-    // The aura network adapter must be the default.
-    {
-        shouldHandleRequest() {
-            return true;
-        },
-        adapter: auraNetworkAdapter,
-    },
-]);
-// Route dispatcher-synthesized sub-requests (e.g. aggregate-ui) back through
-// the composed adapter so shouldHandleRequest and interceptors apply uniformly.
-registerSubRequestNetworkAdapter(composedNetworkAdapter);
-
-const OBJECT_INFO_PREFIX = 'UiApi::ObjectInfoRepresentation:';
-/**
- * Watch a Luvio instance for metadata changes.
- */
-function setupMetadataWatcher(luvio) {
-    // Watch for object info changes. Since we don't have enough information to understand to which
-    // extent an object info change may impact the application the only thing we do is to clear all
-    // the  persistent storages.
-    luvio.storeWatch(OBJECT_INFO_PREFIX, (entries) => {
-        for (let i = 0, len = entries.length; i < len; i++) {
-            const entry = entries[i];
-            const isObjectInfoUpdated = entry.inserted === false;
-            if (isObjectInfoUpdated) {
-                logObjectInfoChanged();
-                clearStorages().catch(() => {
-                    /* noop */
-                });
-                break;
-            }
-        }
-    });
-}
-
-class RequestStrategyManager {
-    constructor(requestStrategies = []) {
-        this.requestStrategies = [];
-        this.requestStrategiesByAdapterName = new Map();
-        this.register(requestStrategies);
-    }
-    setRequestStrategy(requestStrategy) {
-        const adapterName = requestStrategy.adapterName;
-        if (!this.requestStrategiesByAdapterName.has(adapterName)) {
-            this.requestStrategiesByAdapterName.set(adapterName, requestStrategy);
-            this.requestStrategies.push(requestStrategy);
-            return true;
-        }
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`Registered an already existing request strategy: ${adapterName}`);
-        }
-        return false;
-    }
-    deleteRequestStrategy(requestStrategy) {
-        const adapterName = requestStrategy.adapterName;
-        if (this.requestStrategiesByAdapterName.has(adapterName)) {
-            this.requestStrategiesByAdapterName.delete(adapterName);
-            const indexToRemove = this.requestStrategies.findIndex((strategy) => strategy === requestStrategy);
-            this.requestStrategies.splice(indexToRemove, 1);
-            return true;
-        }
-        if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`Could not find existing request strategy to unregister: ${adapterName}`);
-        }
-        return false;
-    }
-    register(requestStrategies) {
-        return requestStrategies.map((requestStrategy) => this.setRequestStrategy(requestStrategy));
-    }
-    unregister(requestStrategies) {
-        return requestStrategies.map((requestStrategy) => this.deleteRequestStrategy(requestStrategy));
-    }
-    get(adapterName) {
-        return this.requestStrategiesByAdapterName.get(adapterName);
-    }
-    getAll() {
-        return this.requestStrategies;
-    }
-}
-
-/**
- * Manages the state of predictions and notifies registered callbacks when predictions are ready.
- */
-class PredictionsReadyManager {
-    constructor() {
-        /**
-         * Array of callbacks to be executed when predictions are ready.
-         * @private
-         */
-        this.predictionsReadyCallbacks = [];
-        /**
-         * Indicates whether the predictions are ready.
-         * @private
-         */
-        this.predictionsReady = false;
-    }
-    /**
-     * Registers a callback to be called when predictions are ready.
-     * If predictions are already ready, the callback is invoked immediately.
-     *
-     * @param {() => void} callback - The callback function to be executed when predictions are ready.
-     */
-    whenPredictionsReady(callback) {
-        if (this.predictionsReady) {
-            callback();
-        }
-        else {
-            this.predictionsReadyCallbacks.push(callback);
-        }
-    }
-    /**
-     * Notifies that predictions are ready by invoking all registered callbacks.
-     */
-    notifyPredictionsReady() {
-        this.predictionsReady = true;
-        this.predictionsReadyCallbacks.forEach((cb) => cb());
-    }
-    /**
-     * Retrieves the list of callbacks registered to be executed when predictions are ready.
-     *
-     * @returns {Array<() => void>} Array of callback functions.
-     */
-    getCallbacks() {
-        return this.predictionsReadyCallbacks;
-    }
-}
-
-class CacheInclusionPolicyService {
-}
-class Ok {
-  constructor(value) {
-    this.value = value;
-  }
-  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 addAllToSet(targetSet, sourceSet) {
-  for (const element of sourceSet) {
-    targetSet.add(element);
-  }
-}
-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)) {
@@ -11120,9 +9039,12 @@ register({
 // Publish buildPredictorForContext on the force/ldsEngine registration bus so that
 // shared laf loaders can obtain it without a dynamic import of the aura ldsEngineCreator module,
 // which would evaluate this whole bootstrap a second time. See ADR
-// 2026-07-10-pdl-service-provisioner-decoupling. buildPredictorForContext is a hoisted
-// function declaration and internally no-ops (returns undefined) when the PDL gate is
-// off, so registering it unconditionally is safe.
+// 2026-07-10-pdl-service-provisioner-decoupling. Predictive data loading (PDL) has been
+// removed from this default engine creator (LEX now boots the One Runtime / one.app engine
+// creators, which carry their own PDL), so buildPredictorForContext is a permanent no-op
+// that returns undefined. The registration is retained so those shared cross-runtime laf
+// loaders still resolve a defined function off the bus and take their existing
+// "no predictor" path.
 register({
     id: PDL_ENGINE_REGISTRATION_ID,
     buildPredictorForContext,
@@ -11143,91 +9065,6 @@ function setupQueryEvaluators(luvio, store) {
     luvio.registerStoreQueryEvaluator(baseQueryEvaluator);
     luvio.registerTypeQueryEvaluator(UiApiNamespace, RecordRepresentationRepresentationType, recordRepresentationQueryEvaluator);
 }
-let __lexPrefetcher;
-const requestStrategyManager = new RequestStrategyManager();
-/**
- * Registers a request strategy to be utilized by PDL.
- * @param requestStrategy - {@link LexRequestStrategy} The request strategy/strategies to register.
- * @returns boolean | boolean[] - true/false depending on registration success.
- */
-function registerRequestStrategy(...requestStrategy) {
-    const result = requestStrategyManager.register(requestStrategy);
-    return result.length === 1 ? result[0] : result;
-}
-/**
- * Unregisters a request strategy to be utilized by PDL.
- * @param requestStrategy - {@link LexRequestStrategy} The request strategy to unregister.
- * @returns boolean | boolean[] - true/false depending on unregistration success.
- */
-function unregisterRequestStrategy(...requestStrategy) {
-    const result = requestStrategyManager.unregister(requestStrategy);
-    return result.length === 1 ? result[0] : result;
-}
-const predictionsReadyManager = new PredictionsReadyManager();
-function whenPredictionsReady(callback) {
-    predictionsReadyManager.whenPredictionsReady(callback);
-}
-function setupPredictivePrefetcher(luvio) {
-    const allStrategies = [
-        new GetRecordRequestStrategy(luvio, canCombineRecordLayoutRequests.isOpen({ fallback: false })),
-        new GetRecordsRequestStrategy(luvio),
-        new GetRecordActionsRequestStrategy(luvio),
-        new GetRecordAvatarsRequestStrategy(luvio),
-        new GetObjectInfoRequestStrategy(luvio),
-        new GetObjectInfosRequestStrategy(luvio),
-        new GetRelatedListsActionsRequestStrategy(luvio),
-        new GetRelatedListRecordsRequestStrategy(luvio),
-        new GetRelatedListRecordsBatchRequestStrategy(luvio),
-        new GetRelatedListInfoRequestStrategy(luvio),
-        new GetRelatedListInfoBatchRequestStrategy(luvio),
-        new GetListInfoByNameRequestStrategy(luvio),
-        new GetListRecordsByNameRequestStrategy(luvio),
-        new GetApexRequestStrategy(luvio),
-        new GetListInfosByObjectNameRequestStrategy(luvio),
-        new GetListObjectInfoRequestStrategy(luvio),
-        new GetRelatedListsInfoRequestStrategy(luvio),
-        new GetRelatedListActionsRequestStrategy(luvio),
-    ];
-    requestStrategyManager.register(allStrategies);
-    const storage = buildPrefetchStorage(useLocalStorage.isOpen({ fallback: false }), {
-        onPredictionsReadyCallback: () => predictionsReadyManager.notifyPredictionsReady(),
-    });
-    const requestRunner = new LexRequestRunner(requestStrategyManager);
-    const repository = new PrefetchRepository(storage, {
-        modifyBeforeSaveHook: (requests) => requestRunner.reduceRequests(requests),
-        modifyPageBeforeSavingHook: (page) => {
-            if (RecordHomePage.handlesContext(__lexPrefetcher.context)) {
-                page.recordTypeId = __lexPrefetcher.context.recordTypeId;
-            }
-        },
-    });
-    const inflightRequestLimit = configService.config.maxAllowedParallelXHRCounts;
-    const prefetcherOptions = {
-        inflightRequestLimit,
-    };
-    const eventEmitter = new PrefetcherEventEmitter();
-    const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, eventEmitter, requestStrategyManager, prefetcherOptions);
-    registerPrefetcher(luvio, prefetcher);
-    registerPrefetcher$1(luvio, prefetcher);
-    __lexPrefetcher = prefetcher;
-}
-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) {
@@ -11244,70 +9081,16 @@ const notifyUpdateAvailableFactory = (luvio) => {
     };
 };
 /**
- * @typedef {Object} RecordHomePageContext
- * @property {string} objectApiName - The API name of the object.
- * @property {string} recordId - The unique identifier for the record.
- * @property {string} actionName - The name of the action being performed.
- * @property {'recordPage'} type - The type of the context, specifically for a record page.
- */
-/**
- * Builds a predictor for a given record home page context. This predictor is responsible for
- * preloading data based on predictions for the current context and create new predictions based
- * on page requests of this context.
+ * Builds a predictor for a given page context.
  *
- * @param {RecordHomePageContext} context - The context for which the predictor is to be built.
- * @returns {{
- *     hasPredictions: () => boolean,
- *     watchPageLoadForPredictions: () => void,
- *     runPredictions: () => ReturnType<Promise<void>>,
- *     getPredictionSummary: () => Map<String,Number>
- * }} An object containing methods to handle predictions:
- *  - hasPredictions: Checks if there are any predictions available.
- *  - watchPageLoadForPredictions: Starts recording the page request for prediction purposes.
- *  - runPredictions: Executes the predictions based on the recorded data and returns a promise
- *    of when those predictions are completed.
- *  - getPredictionSummary: Returns the count of exact and similar prediction requests
+ * Predictive data loading (PDL) has been removed from the default LDS engine creator, so this
+ * is a permanent no-op that returns undefined ("no predictor"). It is retained only to satisfy
+ * the `@salesforce/lds-pdl-engine` bus registration above; shared cross-runtime laf loaders read
+ * it off the bus and already handle an undefined result by skipping predictions. LEX predictive
+ * loading now lives in the One Runtime / one.app engine creators.
  */
-function buildPredictorForContext(context) {
-    // the gate is disabled and the prefetcher was not setup.
-    if (__lexPrefetcher === undefined) {
-        return;
-    }
-    const currentContext = __lexPrefetcher.context;
-    let isSameContext = false;
-    if (RecordHomePage.handlesContext(currentContext) && RecordHomePage.handlesContext(context)) {
-        isSameContext =
-            currentContext.actionName === context.actionName &&
-                currentContext.objectApiName === context.objectApiName &&
-                currentContext.recordId === context.recordId;
-    }
-    else if (ObjectHomePage.handlesContext(currentContext) &&
-        ObjectHomePage.handlesContext(context)) {
-        isSameContext =
-            currentContext.objectApiName === context.objectApiName &&
-                currentContext.listViewApiName === context.listViewApiName;
-    }
-    // // This chunk configures which page we're going to use to try and preload.
-    __lexPrefetcher.context = context;
-    return {
-        hasPredictions() {
-            return __lexPrefetcher.hasPredictions();
-        },
-        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();
-            onIdleDetected(() => __lexPrefetcher.stopRecording());
-        },
-        runPredictions() {
-            if (isSameContext) {
-                return Promise.resolve();
-            }
-            return executeAsyncActivity(METRIC_KEYS.PREDICTIVE_DATA_LOADING_PREDICT, (_act) => __lexPrefetcher.predict(), PDL_EXECUTE_ASYNC_OPTIONS);
-        },
-        getPredictionSummary() {
-            return __lexPrefetcher.getPredictionSummary();
-        },
-    };
+function buildPredictorForContext(_context) {
+    return undefined;
 }
 function initializeLDS() {
     const storeOptions = {
@@ -11323,9 +9106,6 @@ function initializeLDS() {
     setupQueryEvaluators(luvio, store);
     setDefaultLuvio({ luvio });
     setTrackedFieldsConfig();
-    if (usePredictiveLoading.isOpen({ fallback: false })) {
-        setupPredictivePrefetcher(luvio);
-    }
     return luvio; // Return the luvio instance so that we can inject it for OneStore
 }
 // W-23092947: fetch request tags allowed to stay on HTTP on Aura sites (external hosts).
@@ -11456,5 +9236,5 @@ function ldsEngineCreator() {
     return { name: 'ldsEngineCreator' };
 }
 
-export { LexRequestStrategy, PDL_ENGINE_REGISTRATION_ID, PdlPrefetcherEventType, PdlRequestPriority, buildPredictorForContext, configService, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, subscribeToPrefetcherEvents, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.459.0-414dbbb5aa
+export { PDL_ENGINE_REGISTRATION_ID, buildPredictorForContext, configService, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory };
+// version: 1.461.0-37b1c9d1cb