@salesforce/lds-runtime-aura 1.278.0 → 1.280.0

package/dist/ldsEngineCreator.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-/*  *******************************************************************************************
+/*
  *  ATTENTION!
  *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
  *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
@@ -12,19 +12,363 @@
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-import { HttpStatusCode, InMemoryStore, Environment, Luvio, InMemoryStoreQueryEvaluator } from 'force/luvioEngine';
+import { HttpStatusCode, InMemoryStore as InMemoryStore$1, Environment, Luvio, InMemoryStoreQueryEvaluator } from 'force/luvioEngine';
 import ldsTrackedFieldsBehaviorGate from '@salesforce/gate/lds.useNewTrackedFieldBehavior';
 import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
-import { getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListRecordsAdapterFactory, getRelatedListRecordsBatchAdapterFactory, instrument, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
-import { createStorage, clearStorages } from 'force/ldsStorage';
-import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
+import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
+import oneStoreEnabled from '@salesforce/gate/lds.oneStoreEnabled.ltng';
+import { executeGlobalControllerRawResponse } from 'aura';
 import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrument$2 } from 'force/ldsBindings';
 import { counter, registerCacheStats, perfStart, perfEnd, registerPeriodicLogger, interaction, timer } from 'instrumentation/service';
-import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation, onIdleDetected } from 'force/ldsInstrumentation';
+import { LRUCache, instrumentAdapter, instrumentLuvio, setupInstrumentation as setupInstrumentation$1, logObjectInfoChanged as logObjectInfoChanged$1, updatePercentileHistogramMetric, incrementCounterMetric, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation, executeAsyncActivity, METRIC_KEYS, onIdleDetected } from 'force/ldsInstrumentation';
 import auraNetworkAdapter, { instrument as instrument$1, forceRecordTransactionsDisabled, ldsNetworkAdapterInstrument, dispatchAuraAction, defaultActionConfig } from 'force/ldsNetwork';
 import { instrument as instrument$3 } from 'force/adsBridge';
+import { withRegistration as withRegistration$1, register, setDefaultLuvio } from 'force/ldsEngine';
+import { createStorage, clearStorages } from 'force/ldsStorage';
 import { buildJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+const { hasOwnProperty } = Object.prototype;
+
+function resolvedPromiseLike(result) {
+    // Don't nest anything promise like
+    if (isPromiseLike(result)) {
+        return result.then((nextResult) => nextResult);
+    }
+    return {
+        then: (onFulfilled, _onRejected) => {
+            if (onFulfilled) {
+                try {
+                    return resolvedPromiseLike(onFulfilled(result));
+                }
+                catch (e) {
+                    return rejectedPromiseLike(e);
+                }
+            }
+            // assume TResult1 == Result and just pass result down the chain
+            return resolvedPromiseLike(result);
+        },
+    };
+}
+/**
+ * Returns a PromiseLike object that rejects with the specified reason.
+ *
+ * @param reason rejection value
+ * @returns PromiseLike that rejects with reason
+ */
+function rejectedPromiseLike(reason) {
+    if (isPromiseLike(reason)) {
+        return reason.then((nextResult) => nextResult);
+    }
+    return {
+        then: (_onFulfilled, onRejected) => {
+            if (onRejected) {
+                try {
+                    return resolvedPromiseLike(onRejected(reason));
+                }
+                catch (e) {
+                    return rejectedPromiseLike(e);
+                }
+            }
+            // assume TResult2 == Result and just pass rejection down the chain
+            return rejectedPromiseLike(reason);
+        },
+    };
+}
+function isPromiseLike(value) {
+    return (value instanceof Promise ||
+        (typeof value === 'object' &&
+            value !== null &&
+            hasOwnProperty.call(value, 'then') &&
+            typeof value.then === 'function'));
+}
+
+/**
+ * A collection of keys, in no particular order.
+ */
+class KeySetImpl {
+    constructor(initialKeys) {
+        // TODO - probably better to use Set<Key>
+        this.data = {};
+        this.lengthInternal = 0;
+        if (initialKeys) {
+            initialKeys.forEach((key) => {
+                this.add(key);
+            });
+        }
+    }
+    add(key) {
+        this.data[key] = true;
+        // TODO - need to account for adding a key that was already in the set
+        this.lengthInternal++;
+    }
+    contains(key) {
+        return this.data[key] === true;
+    }
+    elements() {
+        return Object.keys(this.data);
+    }
+    get length() {
+        return this.lengthInternal;
+    }
+    overlaps(other) {
+        const otherKeys = other.elements();
+        for (let j = 0; j < otherKeys.length; ++j) {
+            if (this.contains(otherKeys[j])) {
+                return true;
+            }
+        }
+        return false;
+    }
+    difference(other) {
+        const value = new KeySetImpl();
+        this.elements().forEach((key) => {
+            if (!other.contains(key)) {
+                value.add(key);
+            }
+        });
+        return value;
+    }
+    isSubsetOf(other) {
+        return this.difference(other).length === 0;
+    }
+    equals(other) {
+        return this.length === other.length && this.elements().every((key) => other.contains(key));
+    }
+    toString() {
+        return `<<${JSON.stringify(this.elements())}>>`;
+    }
+}
+
+/**
+ * A simple in-memory implementation of the Store interface.
+ *
+ * Exported for testing purposes only.
+ */
+class InMemoryStore {
+    constructor() {
+        this.data = {};
+    }
+    // TODO - only intended for use in tests. We should refactor this into a subclass &
+    // add to a test util library.
+    clear() {
+        this.data = {};
+    }
+    delete(key, _options) {
+        delete this.data[key];
+    }
+    get(key, _options) {
+        return this.data[key];
+    }
+    set(key, value, _options) {
+        this.data[key] = value;
+    }
+    length() {
+        return this.keys().length;
+    }
+    keys() {
+        return new KeySetImpl(Object.keys(this.data));
+    }
+    toKeySet(keys) {
+        return new KeySetImpl(keys);
+    }
+}
+/**
+ * Constructs an in-memory implementation of StoreService.
+ *
+ * @returns in-memory implementation of StoreService
+ */
+function buildInMemoryStoreService() {
+    return {
+        store: new InMemoryStore(),
+    };
+}
+/**
+ * A simple in-memory implementation of the MetadataRepository interface.
+ *
+ * Exported for testing purposes only.
+ */
+class InMemoryMetadataRepository {
+    constructor() {
+        this.data = {};
+    }
+    // TODO - only intended for use in tests. We should refactor this into a subclass &
+    // add to a test util library.
+    clear() {
+        this.data = {};
+    }
+    delete(key, _options) {
+        delete this.data[key];
+    }
+    get(key, _options) {
+        return this.data[key];
+    }
+    set(key, value, _options) {
+        this.data[key] = value;
+    }
+    setPartial(key, value, _options) {
+        const metadata = this.get(key);
+        if (metadata === undefined) {
+            throw new Error(`Metadata for key "${key}" not found`);
+        }
+        this.data[key] = { ...metadata, ...value };
+    }
+    expire(key, options) {
+        const { expirationTime = Date.now() } = options || {};
+        this.setPartial(key, { expirationTime });
+    }
+}
+/**
+ * Constructs an in-memory implementation of MetadataRepositoryService.
+ *
+ * @returns in-memory implementation of MetadataRepositoryService
+ */
+function buildInMemoryMetadataRepositoryService() {
+    return {
+        metadataRepository: new InMemoryMetadataRepository(),
+    };
+}
+
+/**
+ * A simple implementation of KeyKeySubscriptionService.
+ */
+class DefaultKeySubscriptionService {
+    constructor() {
+        this.nextId = 1;
+        this.subscriptions = [];
+    }
+    subscribe(options) {
+        const subscriptionId = this.nextId++;
+        const { subscription, callback } = options;
+        this.subscriptions.push({ subscriptionId, keys: subscription, callback });
+        return () => {
+            this.subscriptions = this.subscriptions.filter((subscription) => subscription.subscriptionId !== subscriptionId);
+        };
+    }
+    publish(keys, _options) {
+        const subscriptions = this.subscriptions.slice();
+        for (let i = 0; i < subscriptions.length; ++i) {
+            const { keys: subscriptionKeys, callback } = subscriptions[i];
+            if (keys.overlaps(subscriptionKeys)) {
+                callback();
+            }
+        }
+        return resolvedPromiseLike(undefined);
+    }
+}
+/**
+ * Constructs a default KeySubscriptionService
+ *
+ * @returns default KeySubscriptionService
+ */
+function buildDefaultKeySubscriptionService() {
+    return {
+        keySubscription: new DefaultKeySubscriptionService(),
+    };
+}
+
+class DefaultTypeNotFoundError extends Error {
+}
+class DefaultTypeRegistry {
+    constructor() {
+        this.registry = {};
+        this.TypeNotFoundError = DefaultTypeNotFoundError;
+    }
+    register(type, _options) {
+        if (!this.registry[type.namespace]) {
+            this.registry[type.namespace] = {};
+        }
+        this.registry[type.namespace][type.typeName] = type;
+    }
+    get(namespace, typeName, _options) {
+        const registryNamespace = this.registry[namespace];
+        if (!registryNamespace) {
+            throw new DefaultTypeNotFoundError(`namespace ${namespace} not found`);
+        }
+        const type = registryNamespace[typeName];
+        if (!type) {
+            throw new DefaultTypeNotFoundError(`type ${typeName} not found in namespace ${namespace}`);
+        }
+        return type;
+    }
+}
+/**
+ * Constructs an in-memory implementation of StoreService.
+ *
+ * @returns in-memory implementation of StoreService
+ */
+function buildDefaultTypeRegistryService() {
+    return {
+        typeRegistry: new DefaultTypeRegistry(),
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Registrations that have already occurred.
+ *
+ * Note that Registrations are maintained as a list rather than a map to allow
+ * the same id to be registered multiple times with potentially different
+ * data.
+ */
+const registrations = [];
+/**
+ * Invokes callback for each Registration, both past & future. That is, callback
+ * will be invoked exactly as many times as register() is called.
+ *
+ * Note that Registration ids are not guaranteed to be unique. The meaning of
+ * multiple Registrations with the same id is determined by the caller(s) of
+ * register().
+ */
+function forEachRegistration(callback) {
+    registrations.forEach((r) => callback(r));
+}
+/**
+ * Invokes callback when the specified id is registered.
+ *
+ * Note that callback may be invoked:
+ *
+ *    - multiple times if multiple calls to register() specify the id
+ *    - never if the specified id is never registered
+ */
+function withRegistration(id, callback) {
+    forEachRegistration((r) => {
+        if (r.id === id) {
+            callback(r);
+        }
+    });
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/**
+ * Indicates if a given instance of a service satisfies a request. Note that this function
+ * assumes the version numbers are valid strings.
+ *
+ * @param provided ServiceVersion of the service instance to be provided
+ * @param requested ServiceVersion requested
+ * @returns true if the service instance to be provided satisfies the request
+ */
+function satisfies(provided, requested) {
+    const providedN = provided.split('.').map((s) => parseInt(s));
+    const requestedN = requested.split('.').map((s) => parseInt(s));
+    return providedN[0] === requestedN[0] && providedN[1] >= requestedN[1];
+}
+
 class PredictivePrefetchPage {
     constructor(context) {
         this.context = context;
@@ -133,122 +477,88 @@ class RecordHomePage extends PredictivePrefetchPage {
     }
 }
 
-class ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner) {
-        this.repository = repository;
-        this.requestRunner = requestRunner;
-        this.isRecording = false;
-        this.queuedPredictionRequests = [];
-        this._context = context;
-        this.page = this.getPage();
-    }
-    set context(value) {
-        this._context = value;
-        this.page = this.getPage();
+/**
+ * Observability / Critical Availability Program (230+)
+ *
+ * This file is intended to be used as a consolidated place for all definitions, functions,
+ * and helpers related to "M1"[1].
+ *
+ * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
+ *
+ * [1] Search "[M1] Lightning Data Service Design Spike" in Quip
+ * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
+ */
+const OBSERVABILITY_NAMESPACE = 'LIGHTNING.lds.service';
+const ADAPTER_INVOCATION_COUNT_METRIC_NAME = 'request';
+const ADAPTER_ERROR_COUNT_METRIC_NAME = 'error';
+const NETWORK_ADAPTER_RESPONSE_METRIC_NAME = 'network-response';
+/**
+ * W-8379680
+ * Counter for number of getApex requests.
+ */
+const GET_APEX_REQUEST_COUNT = {
+    get() {
+        return {
+            owner: OBSERVABILITY_NAMESPACE,
+            name: ADAPTER_INVOCATION_COUNT_METRIC_NAME + '.' + NORMALIZED_APEX_ADAPTER_NAME,
+        };
+    },
+};
+/**
+ * W-8828410
+ * Counter for the number of UnfulfilledSnapshotErrors the luvio engine has.
+ */
+const TOTAL_ADAPTER_ERROR_COUNT = {
+    get() {
+        return { owner: OBSERVABILITY_NAMESPACE, name: ADAPTER_ERROR_COUNT_METRIC_NAME };
+    },
+};
+/**
+ * W-8828410
+ * Counter for the number of invocations made into LDS by a wire adapter.
+ */
+const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = {
+    get() {
+        return { owner: OBSERVABILITY_NAMESPACE, name: ADAPTER_INVOCATION_COUNT_METRIC_NAME };
+    },
+};
+
+const { create, keys } = Object;
+const { isArray } = Array;
+const { stringify } = JSON;
+
+/**
+ * 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}"
+ * Modified from the apex implementation to sort arrays non-destructively.
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+function stableJSONStringify$1(node) {
+    // This is for Date values.
+    if (node && node.toJSON && typeof node.toJSON === 'function') {
+        // eslint-disable-next-line no-param-reassign
+        node = node.toJSON();
     }
-    get context() {
-        return this._context;
+    if (node === undefined) {
+        return;
     }
-    async stopRecording() {
-        this.isRecording = false;
-        await this.repository.flushRequestsToStorage();
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
     }
-    startRecording() {
-        this.isRecording = true;
-        this.repository.clearRequestBuffer();
-    }
-    saveRequest(request) {
-        if (!this.isRecording) {
-            return Promise.resolve();
-        }
-        const { request: requestToSave, context } = this.page.buildSaveRequestData(request);
-        // No need to diferentiate from predictions requests because these
-        // are made from the adapters factory, which are not prediction aware.
-        return this.repository.saveRequest(context, requestToSave);
-    }
-    async predict() {
-        const exactPageRequests = (await this.repository.getPageRequests(this.context)) || [];
-        const similarPageRequests = await this.getSimilarPageRequests();
-        const alwaysRequests = this.page.getAlwaysRunRequests();
-        const predictedRequests = [
-            ...alwaysRequests,
-            ...this.requestRunner.reduceRequests([
-                ...exactPageRequests,
-                ...similarPageRequests,
-                ...this.page.getAlwaysRunRequests(),
-            ]),
-        ];
-        this.queuedPredictionRequests.push(...predictedRequests);
-        return Promise.all(predictedRequests.map((request) => this.requestRunner.runRequest(request))).then();
-    }
-    hasPredictions() {
-        const exactPageRequests = this.repository.getPageRequests(this.context) || [];
-        const similarPageRequests = this.page.similarContext !== undefined
-            ? this.repository.getPageRequests(this.page.similarContext)
-            : [];
-        return exactPageRequests.length > 0 || similarPageRequests.length > 0;
-    }
-    getSimilarPageRequests() {
-        let resolvedSimilarPageRequests = [];
-        if (this.page.similarContext !== undefined) {
-            const similarPageRequests = this.repository.getPageRequests(this.page.similarContext);
-            if (similarPageRequests !== undefined) {
-                resolvedSimilarPageRequests = similarPageRequests.map((request) => this.page.resolveSimilarRequest(request));
-            }
-        }
-        return resolvedSimilarPageRequests;
-    }
-}
-
-class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner, 
-    // These strategies need to be in sync with the "predictiveDataLoadCapable" list
-    // from scripts/lds-uiapi-plugin.js
-    requestStrategies) {
-        super(context, repository, requestRunner);
-        this.requestStrategies = requestStrategies;
-        this.page = this.getPage();
-    }
-    getPage() {
-        if (RecordHomePage.handlesContext(this.context)) {
-            return new RecordHomePage(this.context, this.requestStrategies);
-        }
-        return new LexDefaultPage(this.context);
-    }
-}
-
-// Copy-pasted from adapter-utils. This util should be extracted from generated code and imported in prefetch repository.
-const { keys: ObjectKeys$2 } = Object;
-const { stringify: JSONStringify } = JSON;
-const { isArray: ArrayIsArray$1 } = Array;
-/**
- * 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$1(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 JSONStringify(node);
+    if (typeof node !== 'object') {
+        return stringify(node);
     }
     let i;
     let out;
-    if (ArrayIsArray$1(node)) {
+    if (isArray(node)) {
+        // copy any array before sorting so we don't mutate the object.
+        // eslint-disable-next-line no-param-reassign
+        node = node.slice(0).sort();
         out = '[';
         for (i = 0; i < node.length; i++) {
             if (i) {
@@ -261,10 +571,10 @@ function stableJSONStringify$1(node) {
     if (node === null) {
         return 'null';
     }
-    const keys = ObjectKeys$2(node).sort();
+    const keys$1 = keys(node).sort();
     out = '';
-    for (i = 0; i < keys.length; i++) {
-        const key = keys[i];
+    for (i = 0; i < keys$1.length; i++) {
+        const key = keys$1[i];
         const value = stableJSONStringify$1(node[key]);
         if (!value) {
             continue;
@@ -272,400 +582,833 @@ function stableJSONStringify$1(node) {
         if (out) {
             out += ',';
         }
-        out += JSONStringify(key) + ':' + value;
+        out += stringify(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 = ObjectKeys$2(objA).filter((key) => objA[key] !== undefined);
-    const keysB = ObjectKeys$2(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;
+function isPromise(value) {
+    // check for Thenable due to test frameworks using custom Promise impls
+    return value !== null && value.then !== undefined;
 }
 
-class PrefetchRepository {
-    constructor(storage) {
-        this.storage = storage;
-        this.requestBuffer = new Map();
-    }
-    clearRequestBuffer() {
-        this.requestBuffer.clear();
-    }
-    async flushRequestsToStorage() {
-        const setPromises = [];
-        for (const [id, batch] of this.requestBuffer) {
-            const rawPage = this.storage.get(id);
-            const page = rawPage === undefined ? { id, requests: [] } : rawPage;
-            batch.forEach(({ request, requestTime }) => {
-                let existingRequestEntry = page.requests.find(({ request: storedRequest }) => deepEquals(storedRequest, request));
-                if (existingRequestEntry === undefined) {
-                    existingRequestEntry = { request, requestMetadata: { requestTimes: [] } };
-                    page.requests.push(existingRequestEntry);
+const APEX_ADAPTER_NAME = 'getApex';
+const NORMALIZED_APEX_ADAPTER_NAME = `Apex.${APEX_ADAPTER_NAME}`;
+const REFRESH_APEX_KEY = 'refreshApex';
+const REFRESH_UIAPI_KEY = 'refreshUiApi';
+const SUPPORTED_KEY = 'refreshSupported';
+const UNSUPPORTED_KEY = 'refreshUnsupported';
+const REFRESH_EVENTSOURCE = 'lds-refresh-summary';
+const REFRESH_EVENTTYPE = 'system';
+const REFRESH_PAYLOAD_TARGET = 'adapters';
+const REFRESH_PAYLOAD_SCOPE = 'lds';
+const INCOMING_WEAKETAG_0_KEY = 'incoming-weaketag-0';
+const EXISTING_WEAKETAG_0_KEY = 'existing-weaketag-0';
+const RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME = 'record-api-name-change-count';
+const NAMESPACE = 'lds';
+const NETWORK_TRANSACTION_NAME = 'lds-network';
+const CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX = 'out-of-ttl-miss';
+// Aggregate Cache Stats and Metrics for all getApex invocations
+const getApexCacheStats = registerLdsCacheStats(NORMALIZED_APEX_ADAPTER_NAME);
+const getApexTtlCacheStats = registerLdsCacheStats(NORMALIZED_APEX_ADAPTER_NAME + ':' + CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX);
+// Observability (READS)
+const getApexRequestCountMetric = counter(GET_APEX_REQUEST_COUNT);
+const totalAdapterRequestSuccessMetric = counter(TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT);
+const totalAdapterErrorMetric = counter(TOTAL_ADAPTER_ERROR_COUNT);
+class Instrumentation {
+    constructor() {
+        this.adapterUnfulfilledErrorCounters = {};
+        this.recordApiNameChangeCounters = {};
+        this.refreshAdapterEvents = {};
+        this.refreshApiCallEventStats = {
+            [REFRESH_APEX_KEY]: 0,
+            [REFRESH_UIAPI_KEY]: 0,
+            [SUPPORTED_KEY]: 0,
+            [UNSUPPORTED_KEY]: 0,
+        };
+        this.lastRefreshApiCall = null;
+        this.weakEtagZeroEvents = {};
+        this.adapterCacheMisses = new LRUCache(250);
+        if (typeof window !== 'undefined' && window.addEventListener) {
+            window.addEventListener('beforeunload', () => {
+                if (keys(this.weakEtagZeroEvents).length > 0) {
+                    perfStart(NETWORK_TRANSACTION_NAME);
+                    perfEnd(NETWORK_TRANSACTION_NAME, this.weakEtagZeroEvents);
                 }
-                existingRequestEntry.requestMetadata.requestTimes.push(requestTime);
             });
-            setPromises.push(this.storage.set(id, page));
-        }
-        this.clearRequestBuffer();
-        await Promise.all(setPromises);
-    }
-    getKeyId(key) {
-        return stableJSONStringify$1(key);
-    }
-    async saveRequest(key, request) {
-        const identifier = this.getKeyId(key);
-        const batchForKey = this.requestBuffer.get(identifier) || [];
-        batchForKey.push({
-            request,
-            requestTime: Date.now(),
-        });
-        this.requestBuffer.set(identifier, batchForKey);
-    }
-    getPage(key) {
-        const identifier = stableJSONStringify$1(key);
-        return this.storage.get(identifier);
-    }
-    getPageRequests(key) {
-        const page = this.getPage(key);
-        if (page === undefined) {
-            return [];
         }
-        return page.requests.map((requestEntry) => requestEntry.request);
-    }
-}
-
-class RequestStrategy {
-    transformForSave(request) {
-        return request;
-    }
-    reduce(requests) {
-        return requests;
-    }
-}
-
-class LuvioAdapterRequestStrategy extends RequestStrategy {
-    /**
-     * 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) {
-        return request;
-    }
-    /**
-     * Filter requests to only those that are for this strategy.
-     *
-     * @param unfilteredRequests array of requests to filter
-     * @returns
-     */
-    filterRequests(unfilteredRequests) {
-        return unfilteredRequests.filter((request) => request.adapterName === this.adapterName);
+        registerPeriodicLogger(NAMESPACE, this.logRefreshStats.bind(this));
     }
     /**
-     * Reduce requests by combining those based on a strategies implementations
-     * of canCombine and combineRequests.
-     * @param unfilteredRequests array of requests to filter
-     * @returns
+     * Instruments an existing adapter to log argus metrics and cache stats.
+     * @param adapter The adapter function.
+     * @param metadata The adapter metadata.
+     * @param wireConfigKeyFn Optional function to transform wire configs to a unique key.
+     * @returns The wrapped adapter.
      */
-    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.config, requests[j].config);
-                    if (hasNotBeenVisited && canCombineConfigs) {
-                        combinedRequest.config = this.combineRequests(combinedRequest.config, requests[j].config);
-                        visitedRequests.add(requests[j]);
-                    }
+    instrumentAdapter(adapter, metadata) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        const { apiFamily, name, ttl } = metadata;
+        const adapterName = normalizeAdapterName(name, apiFamily);
+        const isGetApexAdapter = isApexAdapter(name);
+        const stats = isGetApexAdapter ? getApexCacheStats : registerLdsCacheStats(adapterName);
+        const ttlMissStats = isGetApexAdapter
+            ? getApexTtlCacheStats
+            : registerLdsCacheStats(adapterName + ':' + CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX);
+        /**
+         * W-8076905
+         * Dynamically generated metric. Simple counter for all requests made by this adapter.
+         */
+        const wireAdapterRequestMetric = isGetApexAdapter
+            ? getApexRequestCountMetric
+            : counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_INVOCATION_COUNT_METRIC_NAME, adapterName));
+        const instrumentedAdapter = (config, requestContext) => {
+            // increment overall and adapter request metrics
+            wireAdapterRequestMetric.increment(1);
+            totalAdapterRequestSuccessMetric.increment(1);
+            // execute adapter logic
+            const result = adapter(config, requestContext);
+            // In the case where the adapter returns a non-Pending Snapshot it is constructed out of the store
+            // (cache hit) whereas a Promise<Snapshot> or Pending Snapshot indicates a network request (cache miss).
+            //
+            // Note: we can't do a plain instanceof check for a promise here since the Promise may
+            // originate from another javascript realm (for example: in jest test). Instead we use a
+            // duck-typing approach by checking if the result has a then property.
+            //
+            // For adapters without persistent store:
+            //  - total cache hit ratio:
+            //      [in-memory cache hit count] / ([in-memory cache hit count] + [in-memory cache miss count])
+            // For adapters with persistent store:
+            //  - in-memory cache hit ratio:
+            //      [in-memory cache hit count] / ([in-memory cache hit count] + [in-memory cache miss count])
+            //  - total cache hit ratio:
+            //      ([in-memory cache hit count] + [store cache hit count]) / ([in-memory cache hit count] + [in-memory cache miss count])
+            // if result === null then config is insufficient/invalid so do not log
+            if (isPromise(result)) {
+                stats.logMisses();
+                if (ttl !== undefined) {
+                    this.logAdapterCacheMissOutOfTtlDuration(adapterName, config, ttlMissStats, Date.now(), ttl);
                 }
-                reducedRequests.push(combinedRequest);
-                visitedRequests.add(currentRequest);
             }
-        }
-        return reducedRequests;
+            else if (result !== null) {
+                stats.logHits();
+            }
+            return result;
+        };
+        // Set the name property on the function for debugging purposes.
+        Object.defineProperty(instrumentedAdapter, 'name', {
+            value: name + '__instrumented',
+        });
+        return instrumentAdapter(instrumentedAdapter, metadata);
     }
     /**
-     * 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
+     * Logs when adapter requests come in. If we have subsequent cache misses on a given config, beyond its TTL then log the duration to metrics.
+     * Backed by an LRU Cache implementation to prevent too many record entries from being stored in-memory.
+     * @param name The wire adapter name.
+     * @param config The config passed into wire adapter.
+     * @param ttlMissStats CacheStatsLogger to log misses out of TTL.
+     * @param currentCacheMissTimestamp Timestamp for when the request was made.
+     * @param ttl TTL for the wire adapter.
      */
-    canCombine(_reqA, _reqB) {
-        return false;
+    logAdapterCacheMissOutOfTtlDuration(name, config, ttlMissStats, currentCacheMissTimestamp, ttl) {
+        const configKey = `${name}:${stableJSONStringify$1(config)}`;
+        const existingCacheMissTimestamp = this.adapterCacheMisses.get(configKey);
+        this.adapterCacheMisses.set(configKey, currentCacheMissTimestamp);
+        if (existingCacheMissTimestamp !== undefined) {
+            const duration = currentCacheMissTimestamp - existingCacheMissTimestamp;
+            if (duration > ttl) {
+                ttlMissStats.logMisses();
+            }
+        }
     }
     /**
-     * Takes two request configs and combines them into a single request config.
+     * Injected to LDS for Luvio specific instrumentation.
      *
-     * @param reqA config of request A
-     * @param reqB config of request B
-     * @returns
+     * @param context The transaction context.
      */
-    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');
+    instrumentLuvio(context) {
+        instrumentLuvio(context);
+        if (this.isRefreshAdapterEvent(context)) {
+            this.aggregateRefreshAdapterEvents(context);
         }
-        return reqA;
+        else if (this.isAdapterUnfulfilledError(context)) {
+            this.incrementAdapterRequestErrorCount(context);
+        }
+        else ;
     }
     /**
-     * Checks adapter config against request context to determine if the request is context dependent.
-     *
-     * By default, requests are not context dependent.
-     * @param request
-     * @returns
+     * Returns whether or not this is a RefreshAdapterEvent.
+     * @param context The transaction context.
+     * @returns Whether or not this is a RefreshAdapterEvent.
      */
-    isContextDependent(_context, _request) {
-        return false;
+    isRefreshAdapterEvent(context) {
+        return context[REFRESH_ADAPTER_EVENT] === true;
     }
     /**
-     * Builds request for saving,
-     *  - transforming the request
-     *  - handling the cases where the request is context dependent (this is homework for the subclass)
-     * @param _similarContext Context with at least one parameter as a wildcard '*'
-     * @param context Exact context for a given page
-     * @param request
-     * @returns
+     * Returns whether or not this is an AdapterUnfulfilledError.
+     * @param context The transaction context.
+     * @returns Whether or not this is an AdapterUnfulfilledError.
      */
-    buildSaveRequestData(_similarContext, context, request) {
-        return {
-            request: this.transformForSave(request),
-            context,
-        };
-    }
-}
-
-function normalizeRecordIds$1(recordIds) {
-    if (!Array.isArray(recordIds)) {
-        return [recordIds];
-    }
-    return recordIds;
-}
-class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = 'getRecordAvatars';
-        this.adapterFactory = getRecordAvatarsAdapterFactory;
+    isAdapterUnfulfilledError(context) {
+        return context[ADAPTER_UNFULFILLED_ERROR] === true;
     }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordIds: [context.recordId],
-            },
-        };
+    /**
+     * Specific instrumentation for getRecordNotifyChange.
+     * temporary implementation to match existing aura call for now
+     *
+     * @param uniqueWeakEtags whether weakEtags match or not
+     * @param error if dispatchResourceRequest fails for any reason
+     */
+    notifyChangeNetwork(uniqueWeakEtags, error) {
+        perfStart(NETWORK_TRANSACTION_NAME);
+        if (error === true) {
+            perfEnd(NETWORK_TRANSACTION_NAME, { 'notify-change-network': 'error' });
+        }
+        else {
+            perfEnd(NETWORK_TRANSACTION_NAME, { 'notify-change-network': uniqueWeakEtags });
+        }
     }
-    buildSaveRequestData(similarContext, context, request) {
-        if (this.isContextDependent(context, request)) {
-            return {
-                request: this.transformForSave({
-                    ...request,
-                    config: {
-                        ...request.config,
-                        recordIds: ['*'],
-                    },
-                }),
-                context: similarContext,
+    /**
+     * Parses and aggregates weakETagZero events to be sent in summarized log line.
+     * @param context The transaction context.
+     */
+    aggregateWeakETagEvents(incomingWeakEtagZero, existingWeakEtagZero, apiName) {
+        const key = 'weaketag-0-' + apiName;
+        if (this.weakEtagZeroEvents[key] === undefined) {
+            this.weakEtagZeroEvents[key] = {
+                [EXISTING_WEAKETAG_0_KEY]: 0,
+                [INCOMING_WEAKETAG_0_KEY]: 0,
             };
         }
-        return {
-            request: this.transformForSave(request),
-            context,
-        };
-    }
-    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)));
+        if (existingWeakEtagZero) {
+            this.weakEtagZeroEvents[key][EXISTING_WEAKETAG_0_KEY] += 1;
+        }
+        if (incomingWeakEtagZero) {
+            this.weakEtagZeroEvents[key][INCOMING_WEAKETAG_0_KEY] += 1;
+        }
     }
-    canCombine(reqA, reqB) {
-        return reqA.formFactor === reqB.formFactor;
+    /**
+     * Aggregates refresh adapter events to be sent in summarized log line.
+     *   - how many times refreshApex is called
+     *   - how many times refresh from lightning/uiRecordApi is called
+     *   - number of supported calls: refreshApex called on apex adapter
+     *   - number of unsupported calls: refreshApex on non-apex adapter
+     *          + any use of refresh from uiRecordApi module
+     *   - count of refresh calls per adapter
+     * @param context The refresh adapter event.
+     */
+    aggregateRefreshAdapterEvents(context) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        // Adding additional logging that getApex adapters can invoke? Read normalizeAdapterName ts-doc.
+        const adapterName = normalizeAdapterName(context.adapterName);
+        if (this.lastRefreshApiCall === REFRESH_APEX_KEY) {
+            if (isApexAdapter(adapterName)) {
+                this.refreshApiCallEventStats[SUPPORTED_KEY] += 1;
+            }
+            else {
+                this.refreshApiCallEventStats[UNSUPPORTED_KEY] += 1;
+            }
+        }
+        else if (this.lastRefreshApiCall === REFRESH_UIAPI_KEY) {
+            this.refreshApiCallEventStats[UNSUPPORTED_KEY] += 1;
+        }
+        if (this.refreshAdapterEvents[adapterName] === undefined) {
+            this.refreshAdapterEvents[adapterName] = 0;
+        }
+        this.refreshAdapterEvents[adapterName] += 1;
+        this.lastRefreshApiCall = null;
     }
-    combineRequests(reqA, reqB) {
-        const combined = { ...reqA };
-        combined.recordIds = Array.from(new Set([...normalizeRecordIds$1(reqA.recordIds), ...normalizeRecordIds$1(reqB.recordIds)]));
-        return combined;
+    /**
+     * Increments call stat for incoming refresh api call, and sets the name
+     * to be used in {@link aggregateRefreshCalls}
+     * @param from The name of the refresh function called.
+     */
+    handleRefreshApiCall(apiName) {
+        this.refreshApiCallEventStats[apiName] += 1;
+        // set function call to be used with aggregateRefreshCalls
+        this.lastRefreshApiCall = apiName;
+    }
+    /**
+     * W-7302241
+     * Logs refresh call summary stats as a LightningInteraction.
+     */
+    logRefreshStats() {
+        if (keys(this.refreshAdapterEvents).length > 0) {
+            interaction(REFRESH_PAYLOAD_TARGET, REFRESH_PAYLOAD_SCOPE, this.refreshAdapterEvents, REFRESH_EVENTSOURCE, REFRESH_EVENTTYPE, this.refreshApiCallEventStats);
+            this.resetRefreshStats();
+        }
+    }
+    /**
+     * Resets the stat trackers for refresh call events.
+     */
+    resetRefreshStats() {
+        this.refreshAdapterEvents = {};
+        this.refreshApiCallEventStats = {
+            [REFRESH_APEX_KEY]: 0,
+            [REFRESH_UIAPI_KEY]: 0,
+            [SUPPORTED_KEY]: 0,
+            [UNSUPPORTED_KEY]: 0,
+        };
+        this.lastRefreshApiCall = null;
+    }
+    /**
+     * W-7801618
+     * Counter for occurrences where the incoming record to be merged has a different apiName.
+     * Dynamically generated metric, stored in an {@link RecordApiNameChangeCounters} object.
+     *
+     * @param context The transaction context.
+     *
+     * Note: Short-lived metric candidate, remove at the end of 230
+     */
+    incrementRecordApiNameChangeCount(_incomingApiName, existingApiName) {
+        let apiNameChangeCounter = this.recordApiNameChangeCounters[existingApiName];
+        if (apiNameChangeCounter === undefined) {
+            apiNameChangeCounter = counter(createMetricsKey(NAMESPACE, RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME, existingApiName));
+            this.recordApiNameChangeCounters[existingApiName] = apiNameChangeCounter;
+        }
+        apiNameChangeCounter.increment(1);
+    }
+    /**
+     * W-8620679
+     * Increment the counter for an UnfulfilledSnapshotError coming from luvio
+     *
+     * @param context The transaction context.
+     */
+    incrementAdapterRequestErrorCount(context) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        const adapterName = normalizeAdapterName(context.adapterName);
+        let adapterRequestErrorCounter = this.adapterUnfulfilledErrorCounters[adapterName];
+        if (adapterRequestErrorCounter === undefined) {
+            adapterRequestErrorCounter = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_ERROR_COUNT_METRIC_NAME, adapterName));
+            this.adapterUnfulfilledErrorCounters[adapterName] = adapterRequestErrorCounter;
+        }
+        adapterRequestErrorCounter.increment(1);
+        totalAdapterErrorMetric.increment(1);
     }
 }
-
-class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = 'getRecord';
-        this.adapterFactory = getRecordAdapterFactory;
+function createMetricsKey(owner, name, unit) {
+    let metricName = name;
+    if (unit) {
+        metricName = metricName + '.' + unit;
     }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordId: context.recordId,
+    return {
+        get() {
+            return { owner: owner, name: metricName };
+        },
+    };
+}
+/**
+ * Returns whether adapter is an Apex one or not.
+ * @param adapterName The name of the adapter.
+ */
+function isApexAdapter(adapterName) {
+    return adapterName.indexOf(APEX_ADAPTER_NAME) > -1;
+}
+/**
+ * Normalizes getApex adapter names to `Apex.getApex`. Non-Apex adapters will be prefixed with
+ * API family, if supplied. Example: `UiApi.getRecord`.
+ *
+ * Note: If you are adding additional logging that can come from getApex adapter contexts that provide
+ * the full getApex adapter name (i.e. getApex_[namespace]_[class]_[function]_[continuation]),
+ * ensure to call this method to normalize all logging to 'getApex'. This
+ * is because Argus has a 50k key cardinality limit. More context: W-8379680.
+ *
+ * @param adapterName The name of the adapter.
+ * @param apiFamily The API family of the adapter.
+ */
+function normalizeAdapterName(adapterName, apiFamily) {
+    if (isApexAdapter(adapterName)) {
+        return NORMALIZED_APEX_ADAPTER_NAME;
+    }
+    return apiFamily ? `${apiFamily}.${adapterName}` : adapterName;
+}
+const timerMetricTracker = create(null);
+/**
+ * Calls instrumentation/service telemetry timer
+ * @param name Name of the metric
+ * @param duration number to update backing percentile histogram, negative numbers ignored
+ */
+function updateTimerMetric(name, duration) {
+    let metric = timerMetricTracker[name];
+    if (metric === undefined) {
+        metric = timer(createMetricsKey(NAMESPACE, name));
+        timerMetricTracker[name] = metric;
+    }
+    timerMetricAddDuration(metric, duration);
+}
+function timerMetricAddDuration(timer, duration) {
+    // Guard against negative values since it causes error to be thrown by MetricsService
+    if (duration >= 0) {
+        timer.addDuration(duration);
+    }
+}
+/**
+ * W-10315098
+ * Increments the counter associated with the request response. Counts are bucketed by status.
+ */
+const requestResponseMetricTracker = create(null);
+function incrementRequestResponseCount(cb) {
+    const status = cb().status;
+    let metric = requestResponseMetricTracker[status];
+    if (metric === undefined) {
+        metric = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, NETWORK_ADAPTER_RESPONSE_METRIC_NAME, `${status.valueOf()}`));
+        requestResponseMetricTracker[status] = metric;
+    }
+    metric.increment();
+}
+function logObjectInfoChanged() {
+    logObjectInfoChanged$1();
+}
+/**
+ * Create a new instrumentation cache stats and return it.
+ *
+ * @param name The cache logger name.
+ */
+function registerLdsCacheStats(name) {
+    return registerCacheStats(`${NAMESPACE}:${name}`);
+}
+/**
+ * Add or overwrite hooks that require aura implementations
+ */
+function setAuraInstrumentationHooks() {
+    instrument({
+        recordConflictsResolved: (serverRequestCount) => {
+            // Ignore 0 values which can originate from ADS bridge
+            if (serverRequestCount > 0) {
+                updatePercentileHistogramMetric('record-conflicts-resolved', serverRequestCount);
+            }
+        },
+        nullDisplayValueConflict: ({ fieldType, areValuesEqual }) => {
+            const metricName = `merge-null-dv-count.${fieldType}`;
+            if (fieldType === 'scalar') {
+                incrementCounterMetric(`${metricName}.${areValuesEqual}`);
+            }
+            else {
+                incrementCounterMetric(metricName);
+            }
+        },
+        getRecordNotifyChangeAllowed: incrementGetRecordNotifyChangeAllowCount,
+        getRecordNotifyChangeDropped: incrementGetRecordNotifyChangeDropCount,
+        notifyRecordUpdateAvailableAllowed: incrementNotifyRecordUpdateAvailableAllowCount,
+        notifyRecordUpdateAvailableDropped: incrementNotifyRecordUpdateAvailableDropCount,
+        recordApiNameChanged: instrumentation.incrementRecordApiNameChangeCount.bind(instrumentation),
+        weakEtagZero: instrumentation.aggregateWeakETagEvents.bind(instrumentation),
+        getRecordNotifyChangeNetworkResult: instrumentation.notifyChangeNetwork.bind(instrumentation),
+    });
+    withRegistration$1('@salesforce/lds-adapters-uiapi', (reg) => setLdsAdaptersUiapiInstrumentation(reg));
+    instrument$1({
+        logCrud: logCRUDLightningInteraction,
+        networkResponse: incrementRequestResponseCount,
+    });
+    instrument$2({
+        refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
+        instrumentAdapter: instrumentation.instrumentAdapter.bind(instrumentation),
+    });
+    instrument$3({
+        timerMetricAddDuration: updateTimerMetric,
+    });
+    // Our getRecord through aggregate-ui CRUD logging has moved
+    // to lds-network-adapter. We still need to respect the
+    // orgs environment setting
+    if (forceRecordTransactionsDisabled === false) {
+        ldsNetworkAdapterInstrument({
+            getRecordAggregateResolve: (cb) => {
+                const { recordId, apiName } = cb();
+                logCRUDLightningInteraction('read', {
+                    recordId,
+                    recordType: apiName,
+                    state: 'SUCCESS',
+                });
             },
-        };
+            getRecordAggregateReject: (cb) => {
+                const recordId = cb();
+                logCRUDLightningInteraction('read', {
+                    recordId,
+                    state: 'ERROR',
+                });
+            },
+        });
+    }
+    withRegistration$1('@salesforce/lds-network-adapter', (reg) => setLdsNetworkAdapterInstrumentation(reg));
+}
+/**
+ * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
+ *
+ * @param luvio The Luvio instance to instrument.
+ * @param store The InMemoryStore to instrument.
+ */
+function setupInstrumentation(luvio, store) {
+    setupInstrumentation$1(luvio, store);
+    setAuraInstrumentationHooks();
+}
+/**
+ * Note: locator.scope is set to 'force_record' in order for the instrumentation gate to work, which will
+ * disable all crud operations if it is on.
+ * @param eventSource - Source of the logging event.
+ * @param attributes - Free form object of attributes to log.
+ */
+function logCRUDLightningInteraction(eventSource, attributes) {
+    interaction(eventSource, 'force_record', null, eventSource, 'crud', attributes);
+}
+const instrumentation = new Instrumentation();
+
+class ApplicationPredictivePrefetcher {
+    constructor(context, repository, requestRunner) {
+        this.repository = repository;
+        this.requestRunner = requestRunner;
+        this.isRecording = false;
+        this.queuedPredictionRequests = [];
+        this._context = context;
+        this.page = this.getPage();
+    }
+    set context(value) {
+        this._context = value;
+        this.page = this.getPage();
+    }
+    get context() {
+        return this._context;
+    }
+    async stopRecording() {
+        this.isRecording = false;
+        await this.repository.flushRequestsToStorage();
+    }
+    startRecording() {
+        this.isRecording = true;
+        this.repository.clearRequestBuffer();
+    }
+    saveRequest(request) {
+        if (!this.isRecording) {
+            return Promise.resolve();
+        }
+        return executeAsyncActivity(METRIC_KEYS.PREDICTIVE_DATA_LOADING_SAVE_REQUEST, (_act) => {
+            const { request: requestToSave, context } = this.page.buildSaveRequestData(request);
+            // No need to differentiate from predictions requests because these
+            // are made from the adapters factory, which are not prediction aware.
+            return this.repository.saveRequest(context, requestToSave);
+        });
+    }
+    async predict() {
+        const exactPageRequests = (await this.repository.getPageRequests(this.context)) || [];
+        const similarPageRequests = await this.getSimilarPageRequests();
+        const alwaysRequests = this.page.getAlwaysRunRequests();
+        const predictedRequests = [
+            ...alwaysRequests,
+            ...this.requestRunner.reduceRequests([
+                ...exactPageRequests,
+                ...similarPageRequests,
+                ...this.page.getAlwaysRunRequests(),
+            ]),
+        ];
+        this.queuedPredictionRequests.push(...predictedRequests);
+        return Promise.all(predictedRequests.map((request) => this.requestRunner.runRequest(request))).then();
+    }
+    getPredictionSummary() {
+        const exactPageRequests = this.repository.getPageRequests(this.context) || [];
+        const similarPageRequests = this.page.similarContext !== undefined
+            ? this.repository.getPageRequests(this.page.similarContext)
+            : [];
+        return { exact: exactPageRequests.length, similar: similarPageRequests.length };
+    }
+    hasPredictions() {
+        const summary = this.getPredictionSummary();
+        return summary.exact > 0 || summary.similar > 0;
+    }
+    getSimilarPageRequests() {
+        let resolvedSimilarPageRequests = [];
+        if (this.page.similarContext !== undefined) {
+            const similarPageRequests = this.repository.getPageRequests(this.page.similarContext);
+            if (similarPageRequests !== undefined) {
+                resolvedSimilarPageRequests = similarPageRequests.map((request) => this.page.resolveSimilarRequest(request));
+            }
+        }
+        return resolvedSimilarPageRequests;
+    }
+}
+
+class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
+    constructor(context, repository, requestRunner, 
+    // These strategies need to be in sync with the "predictiveDataLoadCapable" list
+    // from scripts/lds-uiapi-plugin.js
+    requestStrategies) {
+        super(context, repository, requestRunner);
+        this.requestStrategies = requestStrategies;
+        this.page = this.getPage();
     }
-    transformForSave(request) {
-        if (request.config.fields === undefined && request.config.optionalFields === undefined) {
-            return request;
+    getPage() {
+        if (RecordHomePage.handlesContext(this.context)) {
+            return new RecordHomePage(this.context, this.requestStrategies);
         }
-        let fields = coerceFieldIdArray(request.config.fields) || [];
-        let optionalFields = coerceFieldIdArray(request.config.optionalFields) || [];
-        return {
-            ...request,
-            config: {
-                ...request.config,
-                fields: undefined,
-                optionalFields: [...fields, ...optionalFields],
-            },
-        };
+        return new LexDefaultPage(this.context);
     }
-    canCombine(reqA, reqB) {
-        // must be same record and
-        return (reqA.recordId === reqB.recordId &&
-            // both requests are fields requests
-            (reqA.optionalFields !== undefined || reqB.optionalFields !== undefined) &&
-            (reqB.fields !== undefined || reqB.optionalFields !== undefined));
+}
+
+// Copy-pasted from adapter-utils. This util should be extracted from generated code and imported in prefetch repository.
+const { keys: ObjectKeys$2 } = Object;
+const { stringify: JSONStringify } = JSON;
+const { isArray: ArrayIsArray$1 } = Array;
+/**
+ * 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();
     }
-    combineRequests(reqA, reqB) {
-        const fields = new Set();
-        const optionalFields = new Set();
-        if (reqA.fields !== undefined) {
-            reqA.fields.forEach((field) => fields.add(field));
+    if (node === undefined) {
+        return;
+    }
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
+    }
+    if (typeof node !== 'object') {
+        return JSONStringify(node);
+    }
+    let i;
+    let out;
+    if (ArrayIsArray$1(node)) {
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify(node[i]) || 'null';
         }
-        if (reqB.fields !== undefined) {
-            reqB.fields.forEach((field) => fields.add(field));
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const keys = ObjectKeys$2(node).sort();
+    out = '';
+    for (i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const value = stableJSONStringify(node[key]);
+        if (!value) {
+            continue;
         }
-        if (reqA.optionalFields !== undefined) {
-            reqA.optionalFields.forEach((field) => optionalFields.add(field));
+        if (out) {
+            out += ',';
         }
-        if (reqB.optionalFields !== undefined) {
-            reqB.optionalFields.forEach((field) => optionalFields.add(field));
+        out += JSONStringify(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 = ObjectKeys$2(objA).filter((key) => objA[key] !== undefined);
+    const keysB = ObjectKeys$2(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) {
+        this.storage = storage;
+        this.requestBuffer = new Map();
+    }
+    clearRequestBuffer() {
+        this.requestBuffer.clear();
+    }
+    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;
+                }
+            });
+            setPromises.push(this.storage.set(id, page));
         }
-        return {
-            recordId: reqA.recordId,
-            fields: Array.from(fields),
-            optionalFields: Array.from(optionalFields),
-        };
+        this.clearRequestBuffer();
+        await Promise.all(setPromises);
     }
-    isContextDependent(context, request) {
-        return request.config.recordId === context.recordId;
+    getKeyId(key) {
+        return stableJSONStringify(key);
     }
-    buildSaveRequestData(similarContext, context, request) {
-        if (this.isContextDependent(context, request)) {
-            return {
-                request: this.transformForSave({
-                    ...request,
-                    config: {
-                        ...request.config,
-                        recordId: '*',
-                    },
-                }),
-                context: similarContext,
-            };
+    async saveRequest(key, request) {
+        const identifier = this.getKeyId(key);
+        const batchForKey = this.requestBuffer.get(identifier) || [];
+        batchForKey.push({
+            request,
+            requestTime: Date.now(),
+        });
+        this.requestBuffer.set(identifier, batchForKey);
+    }
+    getPage(key) {
+        const identifier = stableJSONStringify(key);
+        return this.storage.get(identifier);
+    }
+    getPageRequests(key) {
+        const page = this.getPage(key);
+        if (page === undefined) {
+            return [];
         }
-        return {
-            request: this.transformForSave(request),
-            context,
-        };
+        return page.requests.map((requestEntry) => requestEntry.request);
     }
 }
 
-class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = 'getRecords';
-        this.adapterFactory = getRecordsAdapterFactory;
+class RequestStrategy {
+    transformForSave(request) {
+        return request;
     }
-    buildConcreteRequest(similarRequest, context) {
-        return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                records: [{ ...similarRequest.config.records[0], recordIds: [context.recordId] }],
-            },
-        };
+    reduce(requests) {
+        return requests;
     }
-    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;
+}
+
+class LuvioAdapterRequestStrategy extends RequestStrategy {
+    /**
+     * 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) {
+        return request;
+    }
+    /**
+     * Filter requests to only those that are for this strategy.
+     *
+     * @param unfilteredRequests array of requests to filter
+     * @returns
+     */
+    filterRequests(unfilteredRequests) {
+        return unfilteredRequests.filter((request) => 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.config, requests[j].config);
+                    if (hasNotBeenVisited && canCombineConfigs) {
+                        combinedRequest.config = this.combineRequests(combinedRequest.config, requests[j].config);
+                        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;
     }
-    buildSaveRequestData(similarContext, context, request) {
-        if (this.isContextDependent(context, request)) {
-            return {
-                request: this.transformForSave({
-                    ...request,
-                    config: {
-                        ...request.config,
-                        records: [
-                            {
-                                ...request.config.records[0],
-                                recordIds: ['*'],
-                            },
-                        ],
-                    },
-                }),
-                context: similarContext,
-            };
+    /**
+     * 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');
         }
+        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;
+    }
+    /**
+     * Builds request for saving,
+     *  - transforming the request
+     *  - handling the cases where the request is context dependent (this is homework for the subclass)
+     * @param _similarContext Context with at least one parameter as a wildcard '*'
+     * @param context Exact context for a given page
+     * @param request
+     * @returns
+     */
+    buildSaveRequestData(_similarContext, context, request) {
         return {
             request: this.transformForSave(request),
-            context: context,
+            context,
         };
     }
 }
 
-function normalizeRecordIds(recordIds) {
-    if (!ArrayIsArray$1(recordIds)) {
+function normalizeRecordIds$1(recordIds) {
+    if (!Array.isArray(recordIds)) {
         return [recordIds];
     }
     return recordIds;
 }
-function normalizeApiNames(apiNames) {
-    if (apiNames === undefined || apiNames === null) {
-        return [];
-    }
-    return ArrayIsArray$1(apiNames) ? apiNames : [apiNames];
-}
-class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
+class GetRecordAvatarsRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
         super(...arguments);
-        this.adapterName = 'getRecordActions';
-        this.adapterFactory = getRecordActionsAdapterFactory;
+        this.adapterName = 'getRecordAvatars';
+        this.adapterFactory = getRecordAvatarsAdapterFactory;
     }
     buildConcreteRequest(similarRequest, context) {
         return {
@@ -694,99 +1437,83 @@ class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
             context,
         };
     }
-    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)));
     }
+    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;
+    }
 }
 
-class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
+class GetRecordRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
         super(...arguments);
-        this.adapterName = 'getObjectInfo';
-        this.adapterFactory = getObjectInfoAdapterFactory;
+        this.adapterName = 'getRecord';
+        this.adapterFactory = getRecordAdapterFactory;
     }
     buildConcreteRequest(similarRequest, context) {
         return {
             ...similarRequest,
             config: {
                 ...similarRequest.config,
-                objectApiName: context.objectApiName,
+                recordId: context.recordId,
             },
         };
     }
-    buildSaveRequestData(similarContext, context, request) {
-        if (this.isContextDependent(context, request)) {
-            return {
-                request: this.transformForSave(request),
-                context: similarContext,
-            };
+    transformForSave(request) {
+        if (request.config.fields === undefined && request.config.optionalFields === undefined) {
+            return request;
         }
+        let fields = coerceFieldIdArray(request.config.fields) || [];
+        let optionalFields = coerceFieldIdArray(request.config.optionalFields) || [];
         return {
-            request: this.transformForSave(request),
-            context,
+            ...request,
+            config: {
+                ...request.config,
+                fields: undefined,
+                optionalFields: [...fields, ...optionalFields],
+            },
         };
     }
-    isContextDependent(context, request) {
-        return (request.config.objectApiName !== undefined &&
-            context.objectApiName === request.config.objectApiName);
-    }
-}
-
-class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = 'getObjectInfos';
-        this.adapterFactory = getObjectInfosAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest) {
-        return similarRequest;
-    }
-}
-
-const { keys: ObjectKeys$1 } = Object;
-const { isArray: ArrayIsArray, from: ArrayFrom } = Array;
-function isReduceAbleRelatedListConfig(config) {
-    return config.relatedListsActionParameters.every((rlReq) => {
-        return rlReq.relatedListId !== undefined && ObjectKeys$1(rlReq).length === 1;
-    });
-}
-class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = 'getRelatedListsActions';
-        this.adapterFactory = getRelatedListsActionsAdapterFactory;
+    canCombine(reqA, reqB) {
+        // must be same record and
+        return (reqA.recordId === reqB.recordId &&
+            // both requests are fields requests
+            (reqA.optionalFields !== undefined || reqB.optionalFields !== undefined) &&
+            (reqB.fields !== undefined || reqB.optionalFields !== undefined));
     }
-    buildConcreteRequest(similarRequest, context) {
+    combineRequests(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));
+        }
         return {
-            ...similarRequest,
-            config: {
-                ...similarRequest.config,
-                recordIds: [context.recordId],
-            },
+            recordId: reqA.recordId,
+            fields: Array.from(fields),
+            optionalFields: Array.from(optionalFields),
         };
     }
+    isContextDependent(context, request) {
+        return request.config.recordId === context.recordId;
+    }
     buildSaveRequestData(similarContext, context, request) {
         if (this.isContextDependent(context, request)) {
             return {
@@ -794,7 +1521,7 @@ class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy
                     ...request,
                     config: {
                         ...request.config,
-                        recordIds: ['*'],
+                        recordId: '*',
                     },
                 }),
                 context: similarContext,
@@ -803,84 +1530,29 @@ class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy
         return {
             request: this.transformForSave(request),
             context,
-        };
-    }
-    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 ArrayIsArray(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: ArrayFrom(relatedListsIncluded).map((relatedListId) => ({
-                relatedListId,
-            })),
-        };
-    }
-}
-
-class GetRelatedListInfoBatchRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        this.adapterName = 'getRelatedListInfoBatch';
-        this.adapterFactory = getRelatedListInfoBatchAdapterFactory;
-    }
-    buildConcreteRequest(similarRequest, _context) {
-        return similarRequest;
-    }
-    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;
+        };
     }
 }
 
-class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
+class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
         super(...arguments);
-        this.adapterName = 'getRelatedListRecords';
-        this.adapterFactory = getRelatedListRecordsAdapterFactory;
+        this.adapterName = 'getRecords';
+        this.adapterFactory = getRecordsAdapterFactory;
     }
     buildConcreteRequest(similarRequest, context) {
         return {
             ...similarRequest,
             config: {
                 ...similarRequest.config,
-                parentRecordId: context.recordId,
+                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;
+    }
     buildSaveRequestData(similarContext, context, request) {
         if (this.isContextDependent(context, request)) {
             return {
@@ -888,7 +1560,12 @@ class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
                     ...request,
                     config: {
                         ...request.config,
-                        parentRecordId: '*',
+                        records: [
+                            {
+                                ...request.config.records[0],
+                                recordIds: ['*'],
+                            },
+                        ],
                     },
                 }),
                 context: similarContext,
@@ -896,29 +1573,35 @@ class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
         }
         return {
             request: this.transformForSave(request),
-            context,
+            context: context,
         };
     }
-    // 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
-    // Adding reducing is outside of the scope of this PR, but this could potentially be added in the future
-    isContextDependent(context, request) {
-        return context.recordId === request.config.parentRecordId;
-    }
 }
 
-class GetRelatedListRecordsBatchRequestStrategy extends LuvioAdapterRequestStrategy {
+function normalizeRecordIds(recordIds) {
+    if (!ArrayIsArray$1(recordIds)) {
+        return [recordIds];
+    }
+    return recordIds;
+}
+function normalizeApiNames(apiNames) {
+    if (apiNames === undefined || apiNames === null) {
+        return [];
+    }
+    return ArrayIsArray$1(apiNames) ? apiNames : [apiNames];
+}
+class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
         super(...arguments);
-        this.adapterName = 'getRelatedListRecordsBatch';
-        this.adapterFactory = getRelatedListRecordsBatchAdapterFactory;
+        this.adapterName = 'getRecordActions';
+        this.adapterFactory = getRecordActionsAdapterFactory;
     }
     buildConcreteRequest(similarRequest, context) {
         return {
             ...similarRequest,
             config: {
                 ...similarRequest.config,
-                parentRecordId: context.recordId,
+                recordIds: [context.recordId],
             },
         };
     }
@@ -929,7 +1612,7 @@ class GetRelatedListRecordsBatchRequestStrategy extends LuvioAdapterRequestStrat
                     ...request,
                     config: {
                         ...request.config,
-                        parentRecordId: '*',
+                        recordIds: ['*'],
                     },
                 }),
                 context: similarContext,
@@ -940,710 +1623,412 @@ class GetRelatedListRecordsBatchRequestStrategy extends LuvioAdapterRequestStrat
             context,
         };
     }
-    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;
+        return (reqA.retrievalMode === reqB.retrievalMode &&
+            reqA.formFactor === reqB.formFactor &&
+            (reqA.actionTypes || []).toString() === (reqB.actionTypes || []).toString() &&
+            (reqA.sections || []).toString() === (reqB.sections || []).toString());
     }
-    /**
-     * 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$1(relatedListParameter);
-        }));
-        const reqBRelatedListParametersToAdd = reqB.relatedListParameters.filter((relatedListParameter) => {
-            return !relatedListParametersMap.has(stableJSONStringify$1(relatedListParameter));
-        });
-        reqA.relatedListParameters = reqA.relatedListParameters.concat(reqBRelatedListParametersToAdd);
-        return reqA;
-    }
-}
-
-class LexRequestRunner {
-    constructor(luvio) {
-        this.luvio = luvio;
-        this.requestStrategies = {
-            getRecord: new GetRecordRequestStrategy(),
-            getRecords: new GetRecordsRequestStrategy(),
-            getRecordActions: new GetRecordActionsRequestStrategy(),
-            getRecordAvatars: new GetRecordAvatarsRequestStrategy(),
-            getObjectInfo: new GetObjectInfoRequestStrategy(),
-            getObjectInfos: new GetObjectInfosRequestStrategy(),
-            getRelatedListsActions: new GetRelatedListsActionsRequestStrategy(),
-            getRelatedListInfoBatch: new GetRelatedListInfoBatchRequestStrategy(),
-            getRelatedListRecords: new GetRelatedListRecordsRequestStrategy(),
-            getRelatedListRecordsBatch: new GetRelatedListRecordsBatchRequestStrategy(),
-        };
-    }
-    reduceRequests(requests) {
-        return Object.values(this.requestStrategies)
-            .map((strategy) => strategy.reduce(requests))
-            .flat();
-    }
-    runRequest(request) {
-        if (request.adapterName in this.requestStrategies) {
-            const adapterFactory = this.requestStrategies[request.adapterName].adapterFactory;
-            return Promise.resolve(adapterFactory(this.luvio)(request.config)).then();
+        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 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 { keys: ObjectKeys } = Object;
-const DEFAULT_STORAGE_OPTIONS = {
-    name: 'ldsPredictiveLoading',
-    persistent: true,
-    secure: true,
-    maxSize: 7 * 1024 * 1024,
-    expiration: 12 * 60 * 60,
-    clearOnInit: false,
-    debugLogging: false,
-    version: 2,
-};
-function buildAuraPrefetchStorage(options = {}) {
-    const auraStorage = createStorage({
-        ...DEFAULT_STORAGE_OPTIONS,
-        ...options,
-    });
-    const inMemoryStorage = new InMemoryPrefetchStorage();
-    if (auraStorage === null) {
-        return inMemoryStorage;
-    }
-    return new AuraPrefetchStorage(auraStorage, inMemoryStorage);
-}
-class AuraPrefetchStorage {
-    constructor(auraStorage, inMemoryStorage) {
-        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) => {
-            ObjectKeys(results).forEach((key) => this.inMemoryStorage.set(key, results[key]));
-        });
-    }
-    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);
-    }
-}
-
-/**
- * Observability / Critical Availability Program (230+)
- *
- * This file is intended to be used as a consolidated place for all definitions, functions,
- * and helpers related to "M1"[1].
- *
- * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
- *
- * [1] Search "[M1] Lightning Data Service Design Spike" in Quip
- * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
- */
-const OBSERVABILITY_NAMESPACE = 'LIGHTNING.lds.service';
-const ADAPTER_INVOCATION_COUNT_METRIC_NAME = 'request';
-const ADAPTER_ERROR_COUNT_METRIC_NAME = 'error';
-const NETWORK_ADAPTER_RESPONSE_METRIC_NAME = 'network-response';
-/**
- * W-8379680
- * Counter for number of getApex requests.
- */
-const GET_APEX_REQUEST_COUNT = {
-    get() {
-        return {
-            owner: OBSERVABILITY_NAMESPACE,
-            name: ADAPTER_INVOCATION_COUNT_METRIC_NAME + '.' + NORMALIZED_APEX_ADAPTER_NAME,
-        };
-    },
-};
-/**
- * W-8828410
- * Counter for the number of UnfulfilledSnapshotErrors the luvio engine has.
- */
-const TOTAL_ADAPTER_ERROR_COUNT = {
-    get() {
-        return { owner: OBSERVABILITY_NAMESPACE, name: ADAPTER_ERROR_COUNT_METRIC_NAME };
-    },
-};
-/**
- * W-8828410
- * Counter for the number of invocations made into LDS by a wire adapter.
- */
-const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = {
-    get() {
-        return { owner: OBSERVABILITY_NAMESPACE, name: ADAPTER_INVOCATION_COUNT_METRIC_NAME };
-    },
-};
-
-const { create, keys } = Object;
-const { isArray } = Array;
-const { stringify } = JSON;
-
-/**
- * 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}"
- * Modified from the apex implementation to sort arrays non-destructively.
- * @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';
+        return combined;
     }
-    if (typeof node !== 'object') {
-        return stringify(node);
+    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)));
     }
-    let i;
-    let out;
-    if (isArray(node)) {
-        // copy any array before sorting so we don't mutate the object.
-        // eslint-disable-next-line no-param-reassign
-        node = node.slice(0).sort();
-        out = '[';
-        for (i = 0; i < node.length; i++) {
-            if (i) {
-                out += ',';
-            }
-            out += stableJSONStringify(node[i]) || 'null';
-        }
-        return out + ']';
+}
+
+class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getObjectInfo';
+        this.adapterFactory = getObjectInfoAdapterFactory;
     }
-    if (node === null) {
-        return 'null';
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                objectApiName: context.objectApiName,
+            },
+        };
     }
-    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 += ',';
+    buildSaveRequestData(similarContext, context, request) {
+        if (this.isContextDependent(context, request)) {
+            return {
+                request: this.transformForSave(request),
+                context: similarContext,
+            };
         }
-        out += stringify(key) + ':' + value;
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
+    }
+    isContextDependent(context, request) {
+        return (request.config.objectApiName !== undefined &&
+            context.objectApiName === request.config.objectApiName);
     }
-    return '{' + out + '}';
 }
-function isPromise(value) {
-    // check for Thenable due to test frameworks using custom Promise impls
-    return value !== null && value.then !== undefined;
+
+class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getObjectInfos';
+        this.adapterFactory = getObjectInfosAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest) {
+        return similarRequest;
+    }
 }
 
-const APEX_ADAPTER_NAME = 'getApex';
-const NORMALIZED_APEX_ADAPTER_NAME = `Apex.${APEX_ADAPTER_NAME}`;
-const REFRESH_APEX_KEY = 'refreshApex';
-const REFRESH_UIAPI_KEY = 'refreshUiApi';
-const SUPPORTED_KEY = 'refreshSupported';
-const UNSUPPORTED_KEY = 'refreshUnsupported';
-const REFRESH_EVENTSOURCE = 'lds-refresh-summary';
-const REFRESH_EVENTTYPE = 'system';
-const REFRESH_PAYLOAD_TARGET = 'adapters';
-const REFRESH_PAYLOAD_SCOPE = 'lds';
-const INCOMING_WEAKETAG_0_KEY = 'incoming-weaketag-0';
-const EXISTING_WEAKETAG_0_KEY = 'existing-weaketag-0';
-const RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME = 'record-api-name-change-count';
-const NAMESPACE = 'lds';
-const NETWORK_TRANSACTION_NAME = 'lds-network';
-const CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX = 'out-of-ttl-miss';
-// Aggregate Cache Stats and Metrics for all getApex invocations
-const getApexCacheStats = registerLdsCacheStats(NORMALIZED_APEX_ADAPTER_NAME);
-const getApexTtlCacheStats = registerLdsCacheStats(NORMALIZED_APEX_ADAPTER_NAME + ':' + CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX);
-// Observability (READS)
-const getApexRequestCountMetric = counter(GET_APEX_REQUEST_COUNT);
-const totalAdapterRequestSuccessMetric = counter(TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT);
-const totalAdapterErrorMetric = counter(TOTAL_ADAPTER_ERROR_COUNT);
-class Instrumentation {
+const { keys: ObjectKeys$1 } = Object;
+const { isArray: ArrayIsArray, from: ArrayFrom } = Array;
+function isReduceAbleRelatedListConfig(config) {
+    return config.relatedListsActionParameters.every((rlReq) => {
+        return rlReq.relatedListId !== undefined && ObjectKeys$1(rlReq).length === 1;
+    });
+}
+class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
-        this.adapterUnfulfilledErrorCounters = {};
-        this.recordApiNameChangeCounters = {};
-        this.refreshAdapterEvents = {};
-        this.refreshApiCallEventStats = {
-            [REFRESH_APEX_KEY]: 0,
-            [REFRESH_UIAPI_KEY]: 0,
-            [SUPPORTED_KEY]: 0,
-            [UNSUPPORTED_KEY]: 0,
+        super(...arguments);
+        this.adapterName = 'getRelatedListsActions';
+        this.adapterFactory = getRelatedListsActionsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                recordIds: [context.recordId],
+            },
         };
-        this.lastRefreshApiCall = null;
-        this.weakEtagZeroEvents = {};
-        this.adapterCacheMisses = new LRUCache(250);
-        if (typeof window !== 'undefined' && window.addEventListener) {
-            window.addEventListener('beforeunload', () => {
-                if (keys(this.weakEtagZeroEvents).length > 0) {
-                    perfStart(NETWORK_TRANSACTION_NAME);
-                    perfEnd(NETWORK_TRANSACTION_NAME, this.weakEtagZeroEvents);
-                }
-            });
+    }
+    buildSaveRequestData(similarContext, context, request) {
+        if (this.isContextDependent(context, request)) {
+            return {
+                request: this.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        recordIds: ['*'],
+                    },
+                }),
+                context: similarContext,
+            };
         }
-        registerPeriodicLogger(NAMESPACE, this.logRefreshStats.bind(this));
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
+    }
+    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);
     }
     /**
-     * Instruments an existing adapter to log argus metrics and cache stats.
-     * @param adapter The adapter function.
-     * @param metadata The adapter metadata.
-     * @param wireConfigKeyFn Optional function to transform wire configs to a unique key.
-     * @returns The wrapped adapter.
+     * 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
      */
-    instrumentAdapter(adapter, metadata) {
-        // We are consolidating all apex adapter instrumentation calls under a single key
-        const { apiFamily, name, ttl } = metadata;
-        const adapterName = normalizeAdapterName(name, apiFamily);
-        const isGetApexAdapter = isApexAdapter(name);
-        const stats = isGetApexAdapter ? getApexCacheStats : registerLdsCacheStats(adapterName);
-        const ttlMissStats = isGetApexAdapter
-            ? getApexTtlCacheStats
-            : registerLdsCacheStats(adapterName + ':' + CACHE_STATS_OUT_OF_TTL_MISS_POSTFIX);
-        /**
-         * W-8076905
-         * Dynamically generated metric. Simple counter for all requests made by this adapter.
-         */
-        const wireAdapterRequestMetric = isGetApexAdapter
-            ? getApexRequestCountMetric
-            : counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_INVOCATION_COUNT_METRIC_NAME, adapterName));
-        const instrumentedAdapter = (config, requestContext) => {
-            // increment overall and adapter request metrics
-            wireAdapterRequestMetric.increment(1);
-            totalAdapterRequestSuccessMetric.increment(1);
-            // execute adapter logic
-            const result = adapter(config, requestContext);
-            // In the case where the adapter returns a non-Pending Snapshot it is constructed out of the store
-            // (cache hit) whereas a Promise<Snapshot> or Pending Snapshot indicates a network request (cache miss).
-            //
-            // Note: we can't do a plain instanceof check for a promise here since the Promise may
-            // originate from another javascript realm (for example: in jest test). Instead we use a
-            // duck-typing approach by checking if the result has a then property.
-            //
-            // For adapters without persistent store:
-            //  - total cache hit ratio:
-            //      [in-memory cache hit count] / ([in-memory cache hit count] + [in-memory cache miss count])
-            // For adapters with persistent store:
-            //  - in-memory cache hit ratio:
-            //      [in-memory cache hit count] / ([in-memory cache hit count] + [in-memory cache miss count])
-            //  - total cache hit ratio:
-            //      ([in-memory cache hit count] + [store cache hit count]) / ([in-memory cache hit count] + [in-memory cache miss count])
-            // if result === null then config is insufficient/invalid so do not log
-            if (isPromise(result)) {
-                stats.logMisses();
-                if (ttl !== undefined) {
-                    this.logAdapterCacheMissOutOfTtlDuration(adapterName, config, ttlMissStats, Date.now(), ttl);
-                }
-            }
-            else if (result !== null) {
-                stats.logHits();
-            }
-            return result;
-        };
-        // Set the name property on the function for debugging purposes.
-        Object.defineProperty(instrumentedAdapter, 'name', {
-            value: name + '__instrumented',
+    canCombine(reqA, reqB) {
+        const [recordIdA, recordIdB] = [reqA.recordIds, reqB.recordIds].map((recordIds) => {
+            return ArrayIsArray(recordIds)
+                ? recordIds.length === 1
+                    ? recordIds[0]
+                    : null
+                : recordIds;
         });
-        return instrumentAdapter(instrumentedAdapter, metadata);
+        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: ArrayFrom(relatedListsIncluded).map((relatedListId) => ({
+                relatedListId,
+            })),
+        };
+    }
+}
+
+class GetRelatedListInfoBatchRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRelatedListInfoBatch';
+        this.adapterFactory = getRelatedListInfoBatchAdapterFactory;
     }
-    /**
-     * Logs when adapter requests come in. If we have subsequent cache misses on a given config, beyond its TTL then log the duration to metrics.
-     * Backed by an LRU Cache implementation to prevent too many record entries from being stored in-memory.
-     * @param name The wire adapter name.
-     * @param config The config passed into wire adapter.
-     * @param ttlMissStats CacheStatsLogger to log misses out of TTL.
-     * @param currentCacheMissTimestamp Timestamp for when the request was made.
-     * @param ttl TTL for the wire adapter.
-     */
-    logAdapterCacheMissOutOfTtlDuration(name, config, ttlMissStats, currentCacheMissTimestamp, ttl) {
-        const configKey = `${name}:${stableJSONStringify(config)}`;
-        const existingCacheMissTimestamp = this.adapterCacheMisses.get(configKey);
-        this.adapterCacheMisses.set(configKey, currentCacheMissTimestamp);
-        if (existingCacheMissTimestamp !== undefined) {
-            const duration = currentCacheMissTimestamp - existingCacheMissTimestamp;
-            if (duration > ttl) {
-                ttlMissStats.logMisses();
-            }
-        }
+    buildConcreteRequest(similarRequest, _context) {
+        return similarRequest;
     }
-    /**
-     * Injected to LDS for Luvio specific instrumentation.
-     *
-     * @param context The transaction context.
-     */
-    instrumentLuvio(context) {
-        instrumentLuvio(context);
-        if (this.isRefreshAdapterEvent(context)) {
-            this.aggregateRefreshAdapterEvents(context);
-        }
-        else if (this.isAdapterUnfulfilledError(context)) {
-            this.incrementAdapterRequestErrorCount(context);
-        }
-        else ;
+    canCombine(reqA, reqB) {
+        return reqA.parentObjectApiName === reqB.parentObjectApiName;
     }
-    /**
-     * Returns whether or not this is a RefreshAdapterEvent.
-     * @param context The transaction context.
-     * @returns Whether or not this is a RefreshAdapterEvent.
-     */
-    isRefreshAdapterEvent(context) {
-        return context[REFRESH_ADAPTER_EVENT] === true;
+    combineRequests(reqA, reqB) {
+        const combined = { ...reqA };
+        combined.relatedListNames = Array.from(new Set([...reqA.relatedListNames, ...reqB.relatedListNames]));
+        return combined;
     }
-    /**
-     * Returns whether or not this is an AdapterUnfulfilledError.
-     * @param context The transaction context.
-     * @returns Whether or not this is an AdapterUnfulfilledError.
-     */
-    isAdapterUnfulfilledError(context) {
-        return context[ADAPTER_UNFULFILLED_ERROR] === true;
+}
+
+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;
     }
-    /**
-     * Specific instrumentation for getRecordNotifyChange.
-     * temporary implementation to match existing aura call for now
-     *
-     * @param uniqueWeakEtags whether weakEtags match or not
-     * @param error if dispatchResourceRequest fails for any reason
-     */
-    notifyChangeNetwork(uniqueWeakEtags, error) {
-        perfStart(NETWORK_TRANSACTION_NAME);
-        if (error === true) {
-            perfEnd(NETWORK_TRANSACTION_NAME, { 'notify-change-network': 'error' });
-        }
-        else {
-            perfEnd(NETWORK_TRANSACTION_NAME, { 'notify-change-network': uniqueWeakEtags });
-        }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                parentRecordId: context.recordId,
+            },
+        };
     }
-    /**
-     * Parses and aggregates weakETagZero events to be sent in summarized log line.
-     * @param context The transaction context.
-     */
-    aggregateWeakETagEvents(incomingWeakEtagZero, existingWeakEtagZero, apiName) {
-        const key = 'weaketag-0-' + apiName;
-        if (this.weakEtagZeroEvents[key] === undefined) {
-            this.weakEtagZeroEvents[key] = {
-                [EXISTING_WEAKETAG_0_KEY]: 0,
-                [INCOMING_WEAKETAG_0_KEY]: 0,
+    buildSaveRequestData(similarContext, context, request) {
+        if (this.isContextDependent(context, request)) {
+            return {
+                request: this.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        parentRecordId: '*',
+                    },
+                }),
+                context: similarContext,
             };
         }
-        if (existingWeakEtagZero) {
-            this.weakEtagZeroEvents[key][EXISTING_WEAKETAG_0_KEY] += 1;
-        }
-        if (incomingWeakEtagZero) {
-            this.weakEtagZeroEvents[key][INCOMING_WEAKETAG_0_KEY] += 1;
-        }
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
     }
-    /**
-     * Aggregates refresh adapter events to be sent in summarized log line.
-     *   - how many times refreshApex is called
-     *   - how many times refresh from lightning/uiRecordApi is called
-     *   - number of supported calls: refreshApex called on apex adapter
-     *   - number of unsupported calls: refreshApex on non-apex adapter
-     *          + any use of refresh from uiRecordApi module
-     *   - count of refresh calls per adapter
-     * @param context The refresh adapter event.
-     */
-    aggregateRefreshAdapterEvents(context) {
-        // We are consolidating all apex adapter instrumentation calls under a single key
-        // Adding additional logging that getApex adapters can invoke? Read normalizeAdapterName ts-doc.
-        const adapterName = normalizeAdapterName(context.adapterName);
-        if (this.lastRefreshApiCall === REFRESH_APEX_KEY) {
-            if (isApexAdapter(adapterName)) {
-                this.refreshApiCallEventStats[SUPPORTED_KEY] += 1;
-            }
-            else {
-                this.refreshApiCallEventStats[UNSUPPORTED_KEY] += 1;
-            }
-        }
-        else if (this.lastRefreshApiCall === REFRESH_UIAPI_KEY) {
-            this.refreshApiCallEventStats[UNSUPPORTED_KEY] += 1;
-        }
-        if (this.refreshAdapterEvents[adapterName] === undefined) {
-            this.refreshAdapterEvents[adapterName] = 0;
-        }
-        this.refreshAdapterEvents[adapterName] += 1;
-        this.lastRefreshApiCall = null;
+    isContextDependent(context, request) {
+        return context.recordId === request.config.parentRecordId;
     }
     /**
-     * Increments call stat for incoming refresh api call, and sets the name
-     * to be used in {@link aggregateRefreshCalls}
-     * @param from The name of the refresh function called.
+     * 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.
      */
-    handleRefreshApiCall(apiName) {
-        this.refreshApiCallEventStats[apiName] += 1;
-        // set function call to be used with aggregateRefreshCalls
-        this.lastRefreshApiCall = apiName;
+    canCombine(reqA, reqB) {
+        return reqA.parentRecordId === reqB.parentRecordId;
     }
     /**
-     * W-7302241
-     * Logs refresh call summary stats as a LightningInteraction.
+     * Merge the relatedListParameters together between two combinable batch requests.
+     * @param reqA The first GetRelatedListRecordsBatchConfig.
+     * @param reqB The first GetRelatedListRecordsBatchConfig.
+     * @returns The combined request.
      */
-    logRefreshStats() {
-        if (keys(this.refreshAdapterEvents).length > 0) {
-            interaction(REFRESH_PAYLOAD_TARGET, REFRESH_PAYLOAD_SCOPE, this.refreshAdapterEvents, REFRESH_EVENTSOURCE, REFRESH_EVENTTYPE, this.refreshApiCallEventStats);
-            this.resetRefreshStats();
-        }
+    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;
     }
-    /**
-     * Resets the stat trackers for refresh call events.
-     */
-    resetRefreshStats() {
-        this.refreshAdapterEvents = {};
-        this.refreshApiCallEventStats = {
-            [REFRESH_APEX_KEY]: 0,
-            [REFRESH_UIAPI_KEY]: 0,
-            [SUPPORTED_KEY]: 0,
-            [UNSUPPORTED_KEY]: 0,
+}
+
+class GetRelatedListRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = 'getRelatedListRecords';
+        this.adapterFactory = getRelatedListRecordsAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest, context) {
+        return {
+            ...similarRequest,
+            config: {
+                ...similarRequest.config,
+                parentRecordId: context.recordId,
+            },
         };
-        this.lastRefreshApiCall = null;
     }
     /**
-     * W-7801618
-     * Counter for occurrences where the incoming record to be merged has a different apiName.
-     * Dynamically generated metric, stored in an {@link RecordApiNameChangeCounters} object.
      *
-     * @param context The transaction context.
+     * This method returns GetRelatedListRecordsRequest[] that won't be part of a batch request.
      *
-     * Note: Short-lived metric candidate, remove at the end of 230
+     * 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.
      */
-    incrementRecordApiNameChangeCount(_incomingApiName, existingApiName) {
-        let apiNameChangeCounter = this.recordApiNameChangeCounters[existingApiName];
-        if (apiNameChangeCounter === undefined) {
-            apiNameChangeCounter = counter(createMetricsKey(NAMESPACE, RECORD_API_NAME_CHANGE_COUNT_METRIC_NAME, existingApiName));
-            this.recordApiNameChangeCounters[existingApiName] = apiNameChangeCounter;
+    reduce(unfilteredRequests) {
+        // Batch requests by [parentRecordId]->[RelatedListIds]
+        const batchRequests = unfilteredRequests.filter((request) => request.adapterName === GET_RELATED_LIST_RECORDS_BATCH_ADAPTER_NAME).reduce((acc, request) => {
+            // required properties, enforced by adapter typecheck
+            const { parentRecordId, relatedListParameters } = 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((request) => request.adapterName === this.adapterName);
+        return singleRequests.filter((request) => {
+            // required props enforced by adapter typecheck
+            const { parentRecordId, relatedListId } = request.config;
+            const batchForParentRecordId = batchRequests.get(parentRecordId);
+            return !(batchForParentRecordId && batchForParentRecordId.has(relatedListId));
+        });
+    }
+    buildSaveRequestData(similarContext, context, request) {
+        if (this.isContextDependent(context, request)) {
+            return {
+                request: this.transformForSave({
+                    ...request,
+                    config: {
+                        ...request.config,
+                        parentRecordId: '*',
+                    },
+                }),
+                context: similarContext,
+            };
         }
-        apiNameChangeCounter.increment(1);
+        return {
+            request: this.transformForSave(request),
+            context,
+        };
+    }
+    isContextDependent(context, request) {
+        return context.recordId === request.config.parentRecordId;
+    }
+}
+
+class LexRequestRunner {
+    constructor(luvio) {
+        this.luvio = luvio;
+        this.requestStrategies = {
+            getRecord: new GetRecordRequestStrategy(),
+            getRecords: new GetRecordsRequestStrategy(),
+            getRecordActions: new GetRecordActionsRequestStrategy(),
+            getRecordAvatars: new GetRecordAvatarsRequestStrategy(),
+            getObjectInfo: new GetObjectInfoRequestStrategy(),
+            getObjectInfos: new GetObjectInfosRequestStrategy(),
+            getRelatedListsActions: new GetRelatedListsActionsRequestStrategy(),
+            getRelatedListInfoBatch: new GetRelatedListInfoBatchRequestStrategy(),
+            getRelatedListRecords: new GetRelatedListRecordsRequestStrategy(),
+            getRelatedListRecordsBatch: new GetRelatedListRecordsBatchRequestStrategy(),
+        };
     }
-    /**
-     * W-8620679
-     * Increment the counter for an UnfulfilledSnapshotError coming from luvio
-     *
-     * @param context The transaction context.
-     */
-    incrementAdapterRequestErrorCount(context) {
-        // We are consolidating all apex adapter instrumentation calls under a single key
-        const adapterName = normalizeAdapterName(context.adapterName);
-        let adapterRequestErrorCounter = this.adapterUnfulfilledErrorCounters[adapterName];
-        if (adapterRequestErrorCounter === undefined) {
-            adapterRequestErrorCounter = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, ADAPTER_ERROR_COUNT_METRIC_NAME, adapterName));
-            this.adapterUnfulfilledErrorCounters[adapterName] = adapterRequestErrorCounter;
+    reduceRequests(requests) {
+        return Object.values(this.requestStrategies)
+            .map((strategy) => strategy.reduce(requests))
+            .flat();
+    }
+    runRequest(request) {
+        if (request.adapterName in this.requestStrategies) {
+            const adapterFactory = this.requestStrategies[request.adapterName].adapterFactory;
+            return Promise.resolve(adapterFactory(this.luvio)(request.config)).then();
         }
-        adapterRequestErrorCounter.increment(1);
-        totalAdapterErrorMetric.increment(1);
+        return Promise.resolve(undefined);
     }
 }
-function createMetricsKey(owner, name, unit) {
-    let metricName = name;
-    if (unit) {
-        metricName = metricName + '.' + unit;
+
+class InMemoryPrefetchStorage {
+    constructor() {
+        this.data = {};
     }
-    return {
-        get() {
-            return { owner: owner, name: metricName };
-        },
-    };
-}
-/**
- * Returns whether adapter is an Apex one or not.
- * @param adapterName The name of the adapter.
- */
-function isApexAdapter(adapterName) {
-    return adapterName.indexOf(APEX_ADAPTER_NAME) > -1;
-}
-/**
- * Normalizes getApex adapter names to `Apex.getApex`. Non-Apex adapters will be prefixed with
- * API family, if supplied. Example: `UiApi.getRecord`.
- *
- * Note: If you are adding additional logging that can come from getApex adapter contexts that provide
- * the full getApex adapter name (i.e. getApex_[namespace]_[class]_[function]_[continuation]),
- * ensure to call this method to normalize all logging to 'getApex'. This
- * is because Argus has a 50k key cardinality limit. More context: W-8379680.
- *
- * @param adapterName The name of the adapter.
- * @param apiFamily The API family of the adapter.
- */
-function normalizeAdapterName(adapterName, apiFamily) {
-    if (isApexAdapter(adapterName)) {
-        return NORMALIZED_APEX_ADAPTER_NAME;
+    set(key, value) {
+        this.data[key] = value;
+        return Promise.resolve();
     }
-    return apiFamily ? `${apiFamily}.${adapterName}` : adapterName;
-}
-const timerMetricTracker = create(null);
-/**
- * Calls instrumentation/service telemetry timer
- * @param name Name of the metric
- * @param duration number to update backing percentile histogram, negative numbers ignored
- */
-function updateTimerMetric(name, duration) {
-    let metric = timerMetricTracker[name];
-    if (metric === undefined) {
-        metric = timer(createMetricsKey(NAMESPACE, name));
-        timerMetricTracker[name] = metric;
+    get(key) {
+        return this.data[key];
     }
-    timerMetricAddDuration(metric, duration);
 }
-function timerMetricAddDuration(timer, duration) {
-    // Guard against negative values since it causes error to be thrown by MetricsService
-    if (duration >= 0) {
-        timer.addDuration(duration);
+
+const { keys: ObjectKeys } = Object;
+const DEFAULT_STORAGE_OPTIONS = {
+    name: 'ldsPredictiveLoading',
+    persistent: true,
+    secure: true,
+    maxSize: 7 * 1024 * 1024,
+    expiration: 12 * 60 * 60,
+    clearOnInit: false,
+    debugLogging: false,
+    version: 3,
+};
+function buildAuraPrefetchStorage(options = {}) {
+    const auraStorage = createStorage({
+        ...DEFAULT_STORAGE_OPTIONS,
+        ...options,
+    });
+    const inMemoryStorage = new InMemoryPrefetchStorage();
+    if (auraStorage === null) {
+        return inMemoryStorage;
     }
+    return new AuraPrefetchStorage(auraStorage, inMemoryStorage);
 }
-/**
- * W-10315098
- * Increments the counter associated with the request response. Counts are bucketed by status.
- */
-const requestResponseMetricTracker = create(null);
-function incrementRequestResponseCount(cb) {
-    const status = cb().status;
-    let metric = requestResponseMetricTracker[status];
-    if (metric === undefined) {
-        metric = counter(createMetricsKey(OBSERVABILITY_NAMESPACE, NETWORK_ADAPTER_RESPONSE_METRIC_NAME, `${status.valueOf()}`));
-        requestResponseMetricTracker[status] = metric;
+class AuraPrefetchStorage {
+    constructor(auraStorage, inMemoryStorage) {
+        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) => {
+            ObjectKeys(results).forEach((key) => this.inMemoryStorage.set(key, results[key]));
+        });
     }
-    metric.increment();
-}
-function logObjectInfoChanged() {
-    logObjectInfoChanged$1();
-}
-/**
- * Create a new instrumentation cache stats and return it.
- *
- * @param name The cache logger name.
- */
-function registerLdsCacheStats(name) {
-    return registerCacheStats(`${NAMESPACE}:${name}`);
-}
-/**
- * Add or overwrite hooks that require aura implementations
- */
-function setAuraInstrumentationHooks() {
-    instrument({
-        recordConflictsResolved: (serverRequestCount) => {
-            // Ignore 0 values which can originate from ADS bridge
-            if (serverRequestCount > 0) {
-                updatePercentileHistogramMetric('record-conflicts-resolved', serverRequestCount);
-            }
-        },
-        nullDisplayValueConflict: ({ fieldType, areValuesEqual }) => {
-            const metricName = `merge-null-dv-count.${fieldType}`;
-            if (fieldType === 'scalar') {
-                incrementCounterMetric(`${metricName}.${areValuesEqual}`);
-            }
-            else {
-                incrementCounterMetric(metricName);
+    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);
             }
-        },
-        getRecordNotifyChangeAllowed: incrementGetRecordNotifyChangeAllowCount,
-        getRecordNotifyChangeDropped: incrementGetRecordNotifyChangeDropCount,
-        notifyRecordUpdateAvailableAllowed: incrementNotifyRecordUpdateAvailableAllowCount,
-        notifyRecordUpdateAvailableDropped: incrementNotifyRecordUpdateAvailableDropCount,
-        recordApiNameChanged: instrumentation.incrementRecordApiNameChangeCount.bind(instrumentation),
-        weakEtagZero: instrumentation.aggregateWeakETagEvents.bind(instrumentation),
-        getRecordNotifyChangeNetworkResult: instrumentation.notifyChangeNetwork.bind(instrumentation),
-    });
-    withRegistration('@salesforce/lds-adapters-uiapi', (reg) => setLdsAdaptersUiapiInstrumentation(reg));
-    instrument$1({
-        logCrud: logCRUDLightningInteraction,
-        networkResponse: incrementRequestResponseCount,
-    });
-    instrument$2({
-        refreshCalled: instrumentation.handleRefreshApiCall.bind(instrumentation),
-        instrumentAdapter: instrumentation.instrumentAdapter.bind(instrumentation),
-    });
-    instrument$3({
-        timerMetricAddDuration: updateTimerMetric,
-    });
-    // Our getRecord through aggregate-ui CRUD logging has moved
-    // to lds-network-adapter. We still need to respect the
-    // orgs environment setting
-    if (forceRecordTransactionsDisabled === false) {
-        ldsNetworkAdapterInstrument({
-            getRecordAggregateResolve: (cb) => {
-                const { recordId, apiName } = cb();
-                logCRUDLightningInteraction('read', {
-                    recordId,
-                    recordType: apiName,
-                    state: 'SUCCESS',
-                });
-            },
-            getRecordAggregateReject: (cb) => {
-                const recordId = cb();
-                logCRUDLightningInteraction('read', {
-                    recordId,
-                    state: 'ERROR',
-                });
-            },
         });
+        return inMemoryResult;
+    }
+    get(key) {
+        // we never read from the AuraStorage, except in construction.
+        return this.inMemoryStorage.get(key);
     }
-    withRegistration('@salesforce/lds-network-adapter', (reg) => setLdsNetworkAdapterInstrumentation(reg));
-}
-/**
- * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
- *
- * @param luvio The Luvio instance to instrument.
- * @param store The InMemoryStore to instrument.
- */
-function setupInstrumentation(luvio, store) {
-    setupInstrumentation$1(luvio, store);
-    setAuraInstrumentationHooks();
-}
-/**
- * Note: locator.scope is set to 'force_record' in order for the instrumentation gate to work, which will
- * disable all crud operations if it is on.
- * @param eventSource - Source of the logging event.
- * @param attributes - Free form object of attributes to log.
- */
-function logCRUDLightningInteraction(eventSource, attributes) {
-    interaction(eventSource, 'force_record', null, eventSource, 'crud', attributes);
 }
-const instrumentation = new Instrumentation();
 
 class NoComposedAdapterTypeError extends TypeError {
     constructor(message, resourceRequest) {
@@ -1817,33 +2202,6 @@ function setupPredictivePrefetcher(luvio) {
     registerPrefetcher(luvio, prefetcher);
     __lexPrefetcher = prefetcher;
 }
-/**
- * @deprecated This function is deprecated in favor of `buildPredictorForContext`.
- *    We only keep it so if the lds.usePredictiveLoading gate is open the existing functionality
- *    on LASR don't break.
- *    Note: we don't want to make it a noop either because then the gate toggle will be meaningless.
- */
-async function predictiveLoadPage(preloadProps, runPredictions) {
-    // the gate is disabled and the prefetcher was not setup.
-    if (__lexPrefetcher === undefined) {
-        return;
-    }
-    // This chunk configures which page we're going to use to try and preload.
-    const { objectApiName } = preloadProps.context;
-    const { recordId, actionName } = preloadProps.pageReference.attributes;
-    __lexPrefetcher.context = {
-        objectApiName,
-        recordId,
-        actionName,
-        type: 'recordPage',
-    };
-    // 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();
-    });
-    return runPredictions ? __lexPrefetcher.predict() : Promise.resolve();
-}
 /**
  * @typedef {Object} RecordHomePageContext
  * @property {string} objectApiName - The API name of the object.
@@ -1860,12 +2218,14 @@ async function predictiveLoadPage(preloadProps, runPredictions) {
  * @returns {{
  *     hasPredictions: () => boolean,
  *     watchPageLoadForPredictions: () => void,
- *     runPredictions: () => ReturnType<Promise<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
  */
 function buildPredictorForContext(context) {
     // the gate is disabled and the prefetcher was not setup.
@@ -1886,7 +2246,10 @@ function buildPredictorForContext(context) {
             });
         },
         runPredictions() {
-            return __lexPrefetcher.predict();
+            return executeAsyncActivity(METRIC_KEYS.PREDICTIVE_DATA_LOADING_PREDICT, (_act) => __lexPrefetcher.predict());
+        },
+        getPredictionSummary() {
+            return __lexPrefetcher.getPredictionSummary();
         },
     };
 }
@@ -1895,7 +2258,7 @@ function initializeLDS() {
     const storeOptions = {
         scheduler: () => { },
     };
-    const store = new InMemoryStore(storeOptions);
+    const store = new InMemoryStore$1(storeOptions);
     const environment = new Environment(store, composedNetworkAdapter);
     const luvio = new Luvio(environment, {
         instrument: instrumentation.instrumentLuvio.bind(instrumentation),
@@ -1909,11 +2272,46 @@ function initializeLDS() {
         setupPredictivePrefetcher(luvio);
     }
 }
+// Initializes OneStore in LEX
+function initializeOneStore() {
+    // Build default set of services
+    const services = {
+        ...buildDefaultKeySubscriptionService(),
+        ...buildInMemoryMetadataRepositoryService(),
+        ...buildInMemoryStoreService(),
+        ...buildDefaultTypeRegistryService(),
+        ...buildAuraNetworkService(),
+    };
+    const serviceVersions = {
+        keySubscription: "1.0" /* KeySubscriptionServiceInfo.VERSION */,
+        metadataRepository: "1.0" /* MetadataRepositoryServiceInfo.VERSION */,
+        store: "1.0" /* StoreServiceInfo.VERSION */,
+        typeRegistry: "1.0" /* TypeRegistryServiceInfo.VERSION */,
+        auraNetwork: "1.0" /* AuraNetworkServiceInfo.VERSION */,
+    };
+    withRegistration('commandModule', (registration) => {
+        const matchingServices = {};
+        if (Object.entries(registration.services).every(([service, version]) => service in services &&
+            satisfies(serviceVersions[service], version) &&
+            (matchingServices[service] = services[service]))) {
+            registration.setServices(matchingServices);
+        }
+    });
+}
+function buildAuraNetworkService() {
+    const auraNetwork = {
+        auraNetwork: executeGlobalControllerRawResponse,
+    };
+    return auraNetwork;
+}
 // service function to be invoked by Aura
 function ldsEngineCreator() {
     initializeLDS();
+    if (oneStoreEnabled.isOpen({ fallback: false })) {
+        initializeOneStore();
+    }
     return { name: 'ldsEngineCreator' };
 }
 
-export { buildPredictorForContext, ldsEngineCreator as default, initializeLDS, predictiveLoadPage };
-// version: 1.278.0-f0e8ebcd6
+export { buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore };
+// version: 1.280.0-92c104b03