@salesforce/lds-runtime-aura 1.302.0 → 1.304.0

package/dist/ldsEngineCreator.js

@@ -19,23 +19,439 @@ import useApexPredictions from '@salesforce/gate/lds.pdl.useApexPredictions';
 import useRelatedListsPredictions from '@salesforce/gate/lds.pdl.useRelatedListsPredictions';
 import useCmpDefPredictions from '@salesforce/gate/lds.pdl.useCmpDefPredictions';
 import applyPredictionRequestLimit from '@salesforce/gate/lds.pdl.applyRequestLimit';
-import useExactMatchesPlus from '@salesforce/gate/lds.pdl.useExactMatchesPlus';
+import useExactMatchesPlusGate from '@salesforce/gate/lds.pdl.useExactMatchesPlus';
 import { GetApexWireAdapterFactory, registerPrefetcher as registerPrefetcher$1 } from 'force/ldsAdaptersApex';
-import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, coerceObjectIdArray, getObjectInfoAdapterFactory, coerceObjectId, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, getListInfoByNameAdapterFactory, getListInfosByObjectNameAdapterFactory, getListRecordsByNameAdapterFactory, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
-import { serviceBroker } from 'force/luvioServiceBroker4';
+import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, coerceObjectIdArray, getObjectInfoAdapterFactory, coerceObjectId, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, getListInfoByNameAdapterFactory, getListInfosByObjectNameAdapterFactory, getListRecordsByNameAdapterFactory, getListObjectInfoAdapterFactory, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
+import { BaseCommand, convertAuraResponseToData, convertFetchResponseToData } from 'force/luvioRuntime5';
+import { serviceBroker } from 'force/luvioServiceBroker5';
 import oneStoreEnabled from '@salesforce/gate/lds.oneStoreEnabled.ltng';
 import oneStoreUiapiEnabled from '@salesforce/gate/lds.oneStoreUiapiEnabled.ltng';
 import { getDefinition, executeGlobalControllerRawResponse } from 'aura';
+import { buildJwtNetworkAdapter, setupLexJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
+import auraNetworkAdapter, { dispatchAuraAction, defaultActionConfig, instrument as instrument$1, forceRecordTransactionsDisabled as forceRecordTransactionsDisabled$1, ldsNetworkAdapterInstrument, CrudEventState, CrudEventType, UIAPI_RECORDS_PATH, UIAPI_RELATED_LIST_RECORDS_BATCH_PATH, UIAPI_RELATED_LIST_RECORDS_PATH } from 'force/ldsNetwork';
 import { 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 { 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 auraNetworkAdapter, { instrument as instrument$1, forceRecordTransactionsDisabled, ldsNetworkAdapterInstrument, dispatchAuraAction, defaultActionConfig } from 'force/ldsNetwork';
 import { instrument as instrument$3 } from 'force/adsBridge';
 import { withRegistration, register, setDefaultLuvio } from 'force/ldsEngine';
 import { createStorage, clearStorages } from 'force/ldsStorage';
-import { buildJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
+import useHttpInsteadAuraTransport from '@salesforce/gate/lds.useHttpInsteadAuraTransport';
+import { ThirdPartyTracker } from 'instrumentation:beaconLib';
 import { getObjectInfo, getObjectInfos } from 'force/ldsAdaptersUiapiLex';
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that makes network requests but does not try to
+ * use the store.
+ */
+class NetworkCommand extends BaseCommand {
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    execute() {
+        return this.fetch();
+    }
+}
+function buildNetworkCommandBaseClassService() {
+    return {
+        type: 'networkCommandBaseClass',
+        version: '1.0',
+        service: NetworkCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that makes network requests but does not try to
+ * use the store.
+ */
+class AuraNetworkCommand extends NetworkCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+        this.actionConfig = {
+            background: false,
+            hotspot: true,
+            longRunning: false,
+            storable: false,
+        };
+    }
+    fetch() {
+        return convertAuraResponseToData(this.services.auraNetwork(this.endpoint, this.auraParams, this.actionConfig));
+    }
+}
+function buildAuraNetworkCommandBaseClassService() {
+    return {
+        type: 'auraNetworkCommandBaseClass',
+        version: '1.0',
+        service: AuraNetworkCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that makes network requests but does not try to
+ * use the store.
+ */
+class FetchNetworkCommand extends NetworkCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    fetch() {
+        return convertFetchResponseToData(this.services.fetch(...this.fetchParams));
+    }
+}
+function buildFetchNetworkCommandBaseClassService() {
+    return {
+        type: 'fetchNetworkCommandBaseClass',
+        version: '1.0',
+        service: FetchNetworkCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+function resolvedPromiseLike(result) {
+    // Don't nest anything promise like
+    if (isPromiseOrPromiseLike(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 (isPromiseOrPromiseLike(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 isPromiseOrPromiseLike(value) {
+    return (value instanceof Promise ||
+        (typeof value === 'object' && value !== null && typeof value.then === 'function'));
+}
+
+/**
+ * Converts an arbitrary value to an Error.
+ *
+ * @param x anything
+ * @returns Error corresponding to x
+ */
+function toError(x) {
+    if (x instanceof Error) {
+        return x;
+    }
+    return new Error(`${x}`);
+}
+
+class Ok {
+    constructor(value) {
+        this.value = value;
+    }
+    isOk() {
+        return true;
+    }
+    isErr() {
+        return !this.isOk();
+    }
+}
+class Err {
+    constructor(error) {
+        this.error = error;
+    }
+    isOk() {
+        return false;
+    }
+    isErr() {
+        return !this.isOk();
+    }
+}
+const ok = (value) => new Ok(value);
+const err = (err) => new Err(err);
+// an error to indicate that the data inside a Result construct
+// is missing or incomplete
+class DataNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DataNotFoundError';
+    }
+}
+class DataIncompleteError extends Error {
+    constructor(message, partialData) {
+        super(message);
+        this.partialData = partialData;
+        this.name = 'DataIncompleteError';
+    }
+}
+function isDataNotFoundError(error) {
+    return error instanceof DataNotFoundError || error.name === 'DataNotFoundError';
+}
+function isDataIncompleteError(error) {
+    return error instanceof DataIncompleteError || error.name === 'DataIncompleteError';
+}
+function isCacheHitOrError(value) {
+    if (value.isErr() && (isDataIncompleteError(value.error) || isDataNotFoundError(value.error))) {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of BaseCommand that supports streaming responses and does not use the store.
+ */
+class StreamingCommand extends BaseCommand {
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    execute() {
+        return this.convertFetchStreamResponseToData(this.services.fetch(...this.fetchParams));
+    }
+    convertFetchStreamResponseToData(response) {
+        return response.then((response) => {
+            if (response.ok && response.body) {
+                return ok(this.decodeByteStream(response.body));
+            }
+            else {
+                return err(toError(response.ok ? 'Response body not present' : response.statusText));
+            }
+        }, (reason) => err(toError(reason)));
+    }
+}
+function buildStreamingCommandBaseClassService() {
+    return {
+        type: 'streamingCommandBaseClass',
+        version: '1.0',
+        service: StreamingCommand,
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * An implementation of StreamingCommand that handles SSE (Server-Sent Event) streams.
+ */
+class SSECommand extends StreamingCommand {
+    constructor(services) {
+        super(services);
+        this.services = services;
+    }
+    /**
+     * Decodes the bytes returned by fetch into the correct shape.
+     *
+     * @param byteStream ReadableStream<Uint8Array> returned by fetch
+     * @returns ReadableStream<StreamedData> that will be the result of the Command
+     */
+    decodeByteStream(byteStream) {
+        return this.decodeSSEStream(byteStream
+            // eslint-disable-next-line no-undef
+            .pipeThrough(new TextDecoderStream())
+            .pipeThrough(new SSEParsingStream()));
+    }
+}
+function buildSSECommandBaseClassService() {
+    return {
+        type: 'SSECommandBaseClass',
+        version: '1.0',
+        service: SSECommand,
+    };
+}
+const sseRegex = /^(?<field>[^:]*?)(: ?(?<value>.*?))?(?:\r\n?|\n)/;
+//                 +-------v------++--------v--------++-----v----+
+//                         |                |               |
+//                         |                |        CRLF | CR | LF
+//                         |                |
+//                         |    ": value", or ": comment" if no field name (optional)
+//                         |
+//               field name (optional); can be entire line if no ":"
+class SSEParsingStream extends TransformStream {
+    constructor() {
+        let ignoreLeadingLF = false, partialLine = '', data = '', event = '', id = '', retry;
+        super({
+            transform(chunk, controller) {
+                // account for case where chunk boundary splits \r\n
+                if (ignoreLeadingLF && chunk.startsWith('\n')) {
+                    // eslint-disable-next-line no-param-reassign
+                    chunk = chunk.slice(1);
+                }
+                ignoreLeadingLF = chunk.endsWith('\r');
+                // prepend partial last line from previous chunk
+                let text = partialLine + chunk;
+                let match;
+                while ((match = text.match(sseRegex))) {
+                    text = text.slice(match[0].length);
+                    // blank linke, end of text/event-stream message
+                    if (match.groups.field === '' && match.groups.value === undefined) {
+                        // drop messages with no data
+                        if (data === '') {
+                            event = '';
+                            continue;
+                        }
+                        // strip trailing \n from data
+                        if (data.endsWith('\n')) {
+                            data = data.slice(0, -1);
+                        }
+                        const sseMessage = {
+                            data,
+                            id,
+                            // default event value is "message"
+                            event: event || 'message',
+                        };
+                        if (retry !== undefined) {
+                            sseMessage.retry = retry;
+                        }
+                        controller.enqueue(sseMessage);
+                        // clear data & event for next message; id and retry persist until changed
+                        data = event = '';
+                    }
+                    // data: line
+                    else if (match.groups.field === 'data') {
+                        data += (match.groups.value || '') + '\n';
+                    }
+                    // event: line
+                    else if (match.groups.field === 'event') {
+                        event = match.groups.value || '';
+                    }
+                    // id: line
+                    else if (match.groups.field === 'id') {
+                        const idValue = match.groups.value || '';
+                        if (!idValue.includes('\u0000')) {
+                            id = idValue;
+                        }
+                    }
+                    // retry: line
+                    else if (match.groups.field === 'retry') {
+                        // ignore bogus values
+                        if (/^\d+$/.exec(match.groups.value)) {
+                            retry = parseInt(match.groups.value);
+                        }
+                    }
+                    // comment or unrecognized field, ignore
+                    else ;
+                }
+                // save partial line for next chunk
+                partialLine = text;
+            },
+        });
+    }
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+function buildInstrumentCommand(services) {
+    const meter = services.instrumentation.metrics.getMeter('onestore');
+    return function instrumentCommand(commandClass, commandName) {
+        const invocationCounter = meter.createCounter(`${commandName}.command.invocation.count`);
+        const errorCounter = meter.createCounter(`${commandName}.command.error.count`);
+        const durationHistogram = meter.createHistogram(`${commandName}.command.duration`);
+        return class extends commandClass {
+            execute(...args) {
+                invocationCounter.add(1);
+                let result;
+                const start = performance.now();
+                function recordDuration() {
+                    const end = performance.now();
+                    durationHistogram.record(end - start);
+                }
+                try {
+                    result = super.execute(...args);
+                }
+                catch (e) {
+                    errorCounter.add(1);
+                    throw e;
+                }
+                if (typeof result === 'object' && result !== null && 'then' in result) {
+                    result.then(recordDuration, () => {
+                        errorCounter.add(1);
+                    });
+                }
+                else {
+                    recordDuration();
+                }
+                return result;
+            }
+        };
+    };
+}
+function buildInstrumentCommandServiceDescriptor(services) {
+    return {
+        type: 'instrumentCommand',
+        version: '1.0',
+        service: buildInstrumentCommand(services),
+    };
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -261,67 +677,10 @@ class TTLFilteredStore {
             .keys()
             .elements()
             .filter((key) => this.get(key) !== undefined));
-    }
-    toKeySet(keys) {
-        return this.baseStore.toKeySet(keys);
-    }
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
-function resolvedPromiseLike$1(result) {
-    // Don't nest anything promise like
-    if (isPromiseOrPromiseLike$1(result)) {
-        return result.then((nextResult) => nextResult);
-    }
-    return {
-        then: (onFulfilled, _onRejected) => {
-            if (onFulfilled) {
-                try {
-                    return resolvedPromiseLike$1(onFulfilled(result));
-                }
-                catch (e) {
-                    return rejectedPromiseLike$1(e);
-                }
-            }
-            // assume TResult1 == Result and just pass result down the chain
-            return resolvedPromiseLike$1(result);
-        },
-    };
-}
-/**
- * Returns a PromiseLike object that rejects with the specified reason.
- *
- * @param reason rejection value
- * @returns PromiseLike that rejects with reason
- */
-function rejectedPromiseLike$1(reason) {
-    if (isPromiseOrPromiseLike$1(reason)) {
-        return reason.then((nextResult) => nextResult);
-    }
-    return {
-        then: (_onFulfilled, onRejected) => {
-            if (onRejected) {
-                try {
-                    return resolvedPromiseLike$1(onRejected(reason));
-                }
-                catch (e) {
-                    return rejectedPromiseLike$1(e);
-                }
-            }
-            // assume TResult2 == Result and just pass rejection down the chain
-            return rejectedPromiseLike$1(reason);
-        },
-    };
-}
-function isPromiseOrPromiseLike$1(value) {
-    return (value instanceof Promise ||
-        (typeof value === 'object' && value !== null && typeof value.then === 'function'));
+    }
+    toKeySet(keys) {
+        return this.baseStore.toKeySet(keys);
+    }
 }
 
 /**
@@ -343,7 +702,7 @@ class InMemoryCacheInclusionPolicy {
         const { l1, readFromL1 } = options;
         // l1 is all we've got
         const readResult = readFromL1(l1);
-        return resolvedPromiseLike$1(readResult);
+        return resolvedPromiseLike(readResult);
     }
     /**
      * Writes data to a single level in memory store.
@@ -351,7 +710,7 @@ class InMemoryCacheInclusionPolicy {
     write(options) {
         const { l1, writeToL1 } = options;
         writeToL1(l1);
-        return resolvedPromiseLike$1(undefined);
+        return resolvedPromiseLike(undefined);
     }
 }
 /**
@@ -374,32 +733,6 @@ function buildInMemoryCacheInclusionPolicyService() {
  */
 
 
-// an error to indicate that the data inside a WithErrors construct
-// is missing or incomplete
-let DataNotFoundError$1 = class DataNotFoundError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'DataNotFoundError';
-    }
-};
-function isDataNotFoundError$1(error) {
-    return error instanceof DataNotFoundError$1 || error.name === 'DataNotFoundError';
-}
-function isCacheHitOrError$1(value) {
-    // return cache result if data was found or error was encountered
-    const { data, errors } = value;
-    const cacheHit = data !== undefined && errors.length === 0;
-    const errorEncountered = errors.length > 0 && !isDataNotFoundError$1(errors[0]);
-    return cacheHit || errorEncountered;
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
 class CacheThenNetworkPolicy {
     constructor(services, validator) {
         this.services = services;
@@ -417,7 +750,7 @@ class CacheThenNetworkPolicy {
             writeToCache: (services, networkResult) => this.writeWithValidation(() => writeToCacheOriginal(networkResult, services)),
         });
         return readFromCacheDedupe({ ...this.services, store: ttlStore }).then((value) => {
-            if (isCacheHitOrError$1(value)) {
+            if (isCacheHitOrError(value)) {
                 return value;
             }
             // result not found in cache, try network
@@ -453,24 +786,154 @@ function buildCacheThenNetworkPolicy(services, validator) {
  * For full license text, see the LICENSE.txt file
  */
 
+class NoopOTelTraceAPI {
+    getTracer(_name, _version, _options) {
+        return new NoopTracer();
+    }
+}
+class NoopTracer {
+    startSpan(_name, _options, _context) {
+        return new NoopSpan();
+    }
+    startActiveSpan(name, options, context, fn) {
+        let opts;
+        let ctx;
+        let fun;
+        if (typeof options === 'function') {
+            fun = options;
+        }
+        else {
+            opts = options;
+            if (typeof context === 'function') {
+                fun = context;
+            }
+            else {
+                ctx = context;
+                fun = fn;
+            }
+        }
+        const span = this.startSpan(name, opts, ctx);
+        try {
+            return fun(span);
+        }
+        finally {
+            span.end();
+        }
+    }
+}
+class NoopSpan {
+    spanContext() {
+        // TODO: I'll need to double check, but I think even if we provide a
+        // noop implementation, there is still a requirement to pass along context
+        return {
+            spanId: 'noopSpanId',
+            traceId: 'noopTraceId',
+            traceFlags: 0,
+        };
+    }
+    setAttribute(_key, _value) {
+        return this;
+    }
+    setAttributes(_attributes) {
+        return this;
+    }
+    addEvent(_name, _attributesOrStartTime, _startTime) {
+        return this;
+    }
+    setStatus(_status) {
+        return this;
+    }
+    updateName(_name) {
+        return this;
+    }
+    end(_endTime) {
+        return;
+    }
+    isRecording() {
+        return false;
+    }
+    recordException(_exception, _time) {
+        return;
+    }
+}
 
-// an error to indicate that the data inside a WithErrors construct
-// is missing or incomplete
-class DataNotFoundError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'DataNotFoundError';
+class NoopOTelMetricsAPI {
+    getMeter(__name, _version, __options) {
+        return new NoopMeter();
     }
 }
-function isDataNotFoundError(error) {
-    return error instanceof DataNotFoundError || error.name === 'DataNotFoundError';
+class NoopMeter {
+    createHistogram(_name, _options) {
+        return new NoopHistogram();
+    }
+    createCounter(_name, _options) {
+        return new NoopCounter();
+    }
+    createUpDownCounter(_name, _options) {
+        return new NoopUpDownCounter();
+    }
+    createObservableGauge(_name, _options) {
+        return new NoopObservableGuage();
+    }
+    createObservableCounter(_name, _options) {
+        return new NoopObservableCounter();
+    }
+    createObservableUpDownCounter(_name, _options) {
+        return new NoopObservableUpDownCounter();
+    }
+    addBatchObservableCallback(_callback, _observables) {
+        return;
+    }
+    removeBatchObservableCallback(_callback, _observables) {
+        return;
+    }
 }
-function isCacheHitOrError(value) {
-    // return cache result if data was found or error was encountered
-    const { data, errors } = value;
-    const cacheHit = data !== undefined && errors.length === 0;
-    const errorEncountered = errors.length > 0 && !isDataNotFoundError(errors[0]);
-    return cacheHit || errorEncountered;
+class NoopCounter {
+    add(_value, _attributes, _context) {
+        return;
+    }
+}
+class NoopHistogram {
+    record(_value, _attributes, _context) {
+        return;
+    }
+}
+class NoopUpDownCounter {
+    add(_value, _attributes, _context) {
+        return;
+    }
+}
+class NoopObservableCounter {
+    addCallback(_callback) {
+        return;
+    }
+    removeCallback(_callback) {
+        return;
+    }
+}
+class NoopObservableGuage {
+    addCallback(_callback) {
+        return;
+    }
+    removeCallback(_callback) {
+        return;
+    }
+}
+class NoopObservableUpDownCounter {
+    addCallback(_callback) {
+        return;
+    }
+    removeCallback(_callback) {
+        return;
+    }
+}
+
+/* eslint-disable no-dupe-class-members */
+function buildNoopInstrumentationService() {
+    return {
+        trace: new NoopOTelTraceAPI(),
+        metrics: new NoopOTelMetricsAPI(),
+    };
 }
 
 /**
@@ -604,101 +1067,412 @@ function buildKeyBasedRequestDedupeService() {
  */
 
 
-function resolvedPromiseLike(result) {
-    // Don't nest anything promise like
-    if (isPromiseOrPromiseLike(result)) {
-        return result.then((nextResult) => nextResult);
+/**
+ * A simple implementation of KeyKeySubscriptionService.
+ */
+class DefaultKeySubscriptionService {
+    constructor() {
+        this.nextId = 1;
+        this.subscriptions = [];
     }
-    return {
-        then: (onFulfilled, _onRejected) => {
-            if (onFulfilled) {
-                try {
-                    return resolvedPromiseLike(onFulfilled(result));
-                }
-                catch (e) {
-                    return rejectedPromiseLike(e);
-                }
+    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();
             }
-            // assume TResult1 == Result and just pass result down the chain
-            return resolvedPromiseLike(result);
-        },
-    };
+        }
+        return resolvedPromiseLike(undefined);
+    }
 }
 /**
- * Returns a PromiseLike object that rejects with the specified reason.
+ * Constructs a default KeySubscriptionService
  *
- * @param reason rejection value
- * @returns PromiseLike that rejects with reason
+ * @returns default KeySubscriptionService
  */
-function rejectedPromiseLike(reason) {
-    if (isPromiseOrPromiseLike(reason)) {
-        return reason.then((nextResult) => nextResult);
+function buildDefaultKeySubscriptionService() {
+    return {
+        type: 'keySubscription',
+        version: '1.0',
+        service: new DefaultKeySubscriptionService(),
+    };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+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 {
-        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);
-        },
+        type: 'typeRegistry',
+        version: '1.0',
+        service: new DefaultTypeRegistry(),
     };
 }
-function isPromiseOrPromiseLike(value) {
-    return (value instanceof Promise ||
-        (typeof value === 'object' && value !== null && typeof value.then === 'function'));
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+function e(e){this.message=e;}e.prototype=new Error,e.prototype.name="InvalidCharacterError";var r="undefined"!=typeof window&&window.atob&&window.atob.bind(window)||function(r){var t=String(r).replace(/=+$/,"");if(t.length%4==1)throw new e("'atob' failed: The string to be decoded is not correctly encoded.");for(var n,o,a=0,i=0,c="";o=t.charAt(i++);~o&&(n=a%4?64*n+o:o,a++%4)?c+=String.fromCharCode(255&n>>(-2*a&6)):0)o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".indexOf(o);return c};function t(e){var t=e.replace(/-/g,"+").replace(/_/g,"/");switch(t.length%4){case 0:break;case 2:t+="==";break;case 3:t+="=";break;default:throw "Illegal base64url string!"}try{return function(e){return decodeURIComponent(r(e).replace(/(.)/g,(function(e,r){var t=r.charCodeAt(0).toString(16).toUpperCase();return t.length<2&&(t="0"+t),"%"+t})))}(t)}catch(e){return r(t)}}function n(e){this.message=e;}function o(e,r){if("string"!=typeof e)throw new n("Invalid token specified");var o=!0===(r=r||{}).header?0:1;try{return JSON.parse(t(e.split(".")[o]))}catch(e){throw new n("Invalid token specified: "+e.message)}}n.prototype=new Error,n.prototype.name="InvalidTokenError";
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+const LogLevelMap = {
+    TRACE: 4,
+    DEBUG: 3,
+    INFO: 2,
+    WARN: 1,
+    ERROR: 0,
+};
+/**
+ * A simple Logger implementation.
+ */
+class ConsoleLogger {
+    constructor(level = 'WARN', 
+    // eslint-disable-next-line no-console
+    printer = console.log, formatter = (level, message) => `${level}: ${message}`) {
+        this.level = level;
+        this.printer = printer;
+        this.formatter = formatter;
+        this.messages = [];
+    }
+    trace(message) {
+        this.log('TRACE', message);
+    }
+    debug(message) {
+        this.log('DEBUG', message);
+    }
+    info(message) {
+        this.log('INFO', message);
+    }
+    warn(message) {
+        this.log('WARN', message);
+    }
+    error(message) {
+        this.log('ERROR', message);
+    }
+    log(level, message) {
+        if (LogLevelMap[level] > LogLevelMap[this.level]) {
+            return;
+        }
+        this.printer(this.formatter(level, message));
+    }
+}
+/**
+ * Constructs a new LoggerService.
+ */
+function loggerService(level, printer, formatter) {
+    return new ConsoleLogger(level, printer, formatter);
+}
+
+/**
+ * Represents a JWT token with its decoded info and optional extra info.
+ *
+ * @typeparam T - Type of the additional payload in the JWT.
+ * @typeparam ExtraInfo - Type of the additional information.
+ */
+class JwtToken {
+    /**
+     * Create a new JwtToken.
+     *
+     * @param _token - The JWT string.
+     * @param _decodedInfo - The decoded information from the JWT.
+     * @param _extraInfo - Any additional information associated with the JWT.
+     */
+    constructor(_token, _decodedInfo, _extraInfo) {
+        this._token = _token;
+        this._decodedInfo = _decodedInfo;
+        this._extraInfo = _extraInfo;
+    }
+    /**
+     * Get the JWT string.
+     *
+     * @returns The JWT string.
+     */
+    get token() {
+        return this._token;
+    }
+    /**
+     * Get the additional information associated with the JWT.
+     *
+     * @returns The additional information.
+     */
+    get extraInfo() {
+        return this._extraInfo;
+    }
+    /**
+     * Get the decoded information from the JWT.
+     *
+     * @returns The decoded information.
+     */
+    get decodedInfo() {
+        return this._decodedInfo;
+    }
+    /**
+     * Get the remaining time in seconds until the JWT expires.
+     *
+     * @returns The remaining time in seconds.
+     */
+    get tokenRemainingSeconds() {
+        return this.decodedInfo.exp - Date.now() / 1000;
+    }
+    /**
+     * Check if the JWT is expired.
+     *
+     * @returns True if the JWT is expired, false otherwise.
+     */
+    get isExpired() {
+        return this.tokenRemainingSeconds <= 0;
+    }
 }
 
 /**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
+ * Default logger if none is provided. Is overwritten in non-production environments.
  */
-
-
+let defaultLogger = {
+    trace: () => { },
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};
+if (process.env.NODE_ENV !== 'production') {
+    defaultLogger = loggerService();
+}
 /**
- * A simple implementation of KeyKeySubscriptionService.
+ * Decodes JWT token information and provides a default expiry if none is present.
+ *
+ * @param token - JWT token as a string.
+ * @param defaultTokenTTLInSeconds - Default expiry time in seconds if "exp" claim is not present in token.
+ * @param logger - Logger for logging warnings and errors.
+ *
+ * @returns An object of decoded JWT token information.
  */
-class DefaultKeySubscriptionService {
-    constructor() {
-        this.nextId = 1;
-        this.subscriptions = [];
+function computeDecodedInfo(token, defaultTokenTTLInSeconds, logger) {
+    const decodedInfo = o(token);
+    if (decodedInfo.exp === undefined) {
+        logger.warn(`"exp" claim is not present in the provided token.`);
+        decodedInfo.exp = Date.now() / 1000 + defaultTokenTTLInSeconds;
     }
-    subscribe(options) {
-        const subscriptionId = this.nextId++;
-        const { subscription, callback } = options;
-        this.subscriptions.push({ subscriptionId, keys: subscription, callback });
+    return decodedInfo;
+}
+/**
+ * A repository for JWT tokens.
+ */
+class JwtRepository {
+    /**
+     * @param limitInSeconds - Time in seconds before the token's expiry to notify observers.
+     * @param defaultTokenTTLInSeconds - Default token expiry time in seconds if "exp" claim is not present in token.
+     * @param logger - Logger for logging warnings and errors.
+     */
+    constructor(limitInSeconds = 5, defaultTokenTTLInSeconds = 120, logger = defaultLogger) {
+        this.limitInSeconds = limitInSeconds;
+        this.defaultTokenTTLInSeconds = defaultTokenTTLInSeconds;
+        this.logger = logger;
+        this.observers = [];
+    }
+    /**
+     * Get the current token.
+     */
+    get token() {
+        return this._token;
+    }
+    /**
+     * Set the current token.
+     *
+     * @param token - JWT token as a string.
+     * @param extraInfo - Optional extra information.
+     */
+    setToken(token, extraInfo) {
+        const decodedInfo = computeDecodedInfo(token, this.defaultTokenTTLInSeconds, this.logger);
+        this._token = new JwtToken(token, decodedInfo, extraInfo);
+        this.observeTokenExpiration();
+        return this._token;
+    }
+    /**
+     * Remove the current token.
+     */
+    removeToken() {
+        this._token = undefined;
+        this.clearTimeoutHandler();
+    }
+    /**
+     * Subscribe to the token nearing its expiration.
+     *
+     * @param cb - Callback function to execute when token is nearing expiration.
+     */
+    subscribeToTokenNearExpiration(cb) {
+        this.observers.push(cb);
+        this.observeTokenExpiration();
         return () => {
-            this.subscriptions = this.subscriptions.filter((subscription) => subscription.subscriptionId !== subscriptionId);
+            this.observers = this.observers.filter((observer) => observer !== cb);
         };
     }
-    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();
-            }
+    /**
+     * Clear the timeout handler.
+     */
+    clearTimeoutHandler() {
+        if (this.timeoutHandler !== undefined) {
+            clearTimeout(this.timeoutHandler);
         }
-        return resolvedPromiseLike(undefined);
+    }
+    /**
+     * Observe and handle token expiration.
+     */
+    observeTokenExpiration() {
+        this.clearTimeoutHandler();
+        if (this.observers.length === 0 || this.token === undefined) {
+            return;
+        }
+        this.timeoutHandler = setTimeout(() => this.notifyTokenIsExpiring(), this.computeTimeoutTimeInMs());
+    }
+    /**
+     * Compute the timeout time in milliseconds.
+     */
+    computeTimeoutTimeInMs() {
+        const remainingSeconds = this.token.tokenRemainingSeconds;
+        let timeoutTimeInSeconds = remainingSeconds - this.limitInSeconds;
+        return timeoutTimeInSeconds < 0 ? 0 : timeoutTimeInSeconds * 1000;
+    }
+    /**
+     * Notify all observers that the token is expiring.
+     */
+    notifyTokenIsExpiring() {
+        this.observers.forEach((cb) => {
+            try {
+                cb.call(undefined, this.token);
+            }
+            catch (e) {
+                this.logger.error(e.message);
+            }
+        });
     }
 }
+
 /**
- * Constructs a default KeySubscriptionService
+ * JwtManager class.
+ * It provides methods for managing JWT (Json Web Token), such as retrieving and refreshing.
  *
- * @returns default KeySubscriptionService
+ * @template T The data type the JwtToken carries. Default to unknown.
+ * @template ExtraInfo The type of the optional extra information returned by the getJwt method. Defaults to undefined.
+ * @property {JwtRepository<T, ExtraInfo>} jwtRepository JwtRepository instance used for token management.
+ * @property {JwtResolver<ExtraInfo>} resolver JwtResolver instance used for token retrieval.
  */
-function buildDefaultKeySubscriptionService() {
-    return {
-        type: 'keySubscription',
-        version: '1.0',
-        service: new DefaultKeySubscriptionService(),
-    };
+class JwtManager {
+    /**
+     * Constructor for JwtManager class.
+     *
+     * @param {JwtRepository<T, ExtraInfo>} jwtRepository JwtRepository instance used for token management.
+     * @param {JwtResolver<ExtraInfo>} resolver JwtResolver instance used for token retrieval.
+     * @param {JwtManagerOptions} options JwtManagerOptions bag to customize behavior.
+     */
+    constructor(jwtRepository, resolver, options) {
+        this.jwtRepository = jwtRepository;
+        this.resolver = resolver;
+        if (options === null || options === void 0 ? void 0 : options.keepTokenUpdated) {
+            jwtRepository.subscribeToTokenNearExpiration(() => this.refreshToken());
+        }
+    }
+    /**
+     * Method to get a JWT token.
+     * If there's a token request in progress, it will return the Promise of this request.
+     * If the current token is undefined or expired, it will initiate a token refresh.
+     * Otherwise, it will return the current token.
+     *
+     * @returns {JwtToken<T, ExtraInfo> | Promise<JwtToken<T, ExtraInfo>>} The current token or the Promise of a token request.
+     */
+    getJwt() {
+        if (this.inflightPromise) {
+            return this.inflightPromise;
+        }
+        const token = this.jwtRepository.token;
+        if (token === undefined || token.isExpired) {
+            return this.refreshToken();
+        }
+        return token;
+    }
+    /**
+     * Method to refresh a JWT token.
+     * If a refresh request is already in progress, it will return the Promise of this request.
+     * Otherwise, it will start a new refresh request and return its Promise.
+     *
+     * @returns {Promise<JwtToken<T, ExtraInfo>>} Promise of the refreshed token.
+     */
+    refreshToken() {
+        if (this.inflightPromise === undefined) {
+            this.inflightPromise = new Promise((resolve, reject) => {
+                this.resolver
+                    .getJwt()
+                    .then(({ jwt, extraInfo }) => {
+                    this.inflightPromise = undefined;
+                    const token = this.jwtRepository.setToken(jwt, extraInfo);
+                    resolve(token);
+                })
+                    .catch((reason) => {
+                    this.inflightPromise = undefined;
+                    reject(reason);
+                });
+            });
+        }
+        return this.inflightPromise;
+    }
+    /**
+     * Method to check if a token refresh is in progress.
+     *
+     * @returns {boolean} true if a token refresh is in progress, false otherwise.
+     */
+    get isRefreshingToken() {
+        return this.inflightPromise !== undefined;
+    }
 }
 
 /**
@@ -708,41 +1482,194 @@ function buildDefaultKeySubscriptionService() {
  */
 
 
-class DefaultTypeNotFoundError extends Error {
+function buildFetchService(interceptors = { request: [] }) {
+    return {
+        type: 'fetch',
+        version: '1.0',
+        service: function (...args) {
+            const { request: requestInterceptors = [] } = interceptors;
+            const pending = requestInterceptors.reduce((previousPromise, interceptor) => previousPromise.then(interceptor), resolvedPromiseLike(args));
+            return pending.then((args) => fetch(...args));
+        },
+    };
 }
-class DefaultTypeRegistry {
-    constructor() {
-        this.registry = {};
-        this.TypeNotFoundError = DefaultTypeNotFoundError;
-    }
-    register(type, _options) {
-        if (!this.registry[type.namespace]) {
-            this.registry[type.namespace] = {};
+
+const UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE = 'Unexpected Authorization header encountered. To specify a custom Authorization header, use a Fetch service that is not configured with JwtRequestHeaderInterceptor';
+function setHeaderAuthorization({ token }, [resource, options = {}]) {
+    let hasAuthorizationHeaderBeenSet = false;
+    const Authorization = `Bearer ${token}`;
+    // The following is necessary because fetch(RequestInfo, options|RequestInit)
+    // does not merge properties from options|RequestInit.headers into RequestInfo.headers,
+    // instead it will pave over RequestInfo.headers if options|RequestInit.headers
+    // is defined. Therefore, this function must preserve any pre-existing headers
+    // properties across two different arguments that themselves may be four
+    // different data types.
+    //
+    // - a string
+    // - an instance of URL
+    // - an instance of Request
+    //
+    // And for this argument we only need to guard against overwriting an
+    // existing `headers` property whose value is an instance of Headers.
+    // This will only be valid when the resource argument is an instance of
+    // Request, which implicitly holds a property called `headers` whose
+    // value is an instance of Headers AND options has not been explicitly
+    // provided, or has but does not have a headers property. The existance
+    // of an explicit headers property would likely be intentional, so
+    // we defer to the calling code.
+    if (resource instanceof Request && !(options === null || options === void 0 ? void 0 : options.headers)) {
+        // If the resource object's headers instance already contains an
+        // "Authorization" header, then we have to assume this is a mistake
+        // so throw an exception that will result in the fetch call returning
+        // a rejected promise.
+        if (resource.headers.has('Authorization')) {
+            throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
         }
-        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`);
+        // Otherwise, set the "Authorization" header with the provided
+        // JWT value (because options?.headers also doesn't exist)
+        resource.headers.set('Authorization', Authorization);
+        hasAuthorizationHeaderBeenSet = true;
+    }
+    // When the options object is provided, it may already have a
+    // `headers` property whose value is an instance of Headers, or
+    // a `headers` property that is a plain object comprised of key=>value
+    // pairs that will be converted into a Headers object by fetch().
+    //
+    // If the options object contains a property called `headers` whose value
+    // is an instance of Headers...
+    if ((options === null || options === void 0 ? void 0 : options.headers) instanceof Headers) {
+        // ...Check to see if that object contains an "Authorization" header.
+        // If it does, then we have to assume this is a mistake so throw an
+        // exception.
+        if (options === null || options === void 0 ? void 0 : options.headers.has('Authorization')) {
+            throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
         }
-        const type = registryNamespace[typeName];
-        if (!type) {
-            throw new DefaultTypeNotFoundError(`type ${typeName} not found in namespace ${namespace}`);
+        // Otherwise, set the "Authorization" header with the provided
+        // JWT token value:
+        options === null || options === void 0 ? void 0 : options.headers.set('Authorization', Authorization);
+    }
+    else {
+        // Else, check if options contains a `headers` property whose value
+        // is a plain object comprised of key=>value pairs. If this
+        // object contains a property called "Authorization", then we have
+        // to assume this is a mistake so throw an exception.
+        if ((options === null || options === void 0 ? void 0 : options.headers) && Reflect.has(options === null || options === void 0 ? void 0 : options.headers, 'Authorization')) {
+            throw new Error(UNEXPECTED_AUTHORIZATION_HEADER_MESSAGE);
+        }
+        // Otherwise, add a property called "Authorization", whose value is
+        // the provided JWT value, as long as it has not been set on Request
+        if (!hasAuthorizationHeaderBeenSet) {
+            options.headers = {
+                ...options === null || options === void 0 ? void 0 : options.headers,
+                Authorization,
+            };
         }
-        return type;
     }
+    return [resource, options];
+}
+function buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier = (_e, fetchArgs) => fetchArgs) {
+    return (args) => {
+        return resolvedPromiseLike(jwtManager.getJwt()).then((token) => {
+            const fetchArgsWithRequestHeaderAuthorization = setHeaderAuthorization(token, args);
+            return token.extraInfo
+                ? jwtRequestModifier(token.extraInfo, fetchArgsWithRequestHeaderAuthorization)
+                : fetchArgsWithRequestHeaderAuthorization;
+        });
+    };
 }
+
+const SALESFORCE_API_BASE_URI_FLAG = 'api.salesforce.com';
+const SFAPController = 'SalesforceApiPlatformController';
+const SFAPJwtMethod = 'getSFAPLightningJwtService';
 /**
- * Constructs an in-memory implementation of StoreService.
+ * We expect jwt info and baseUri to be present in the response.
  *
- * @returns in-memory implementation of StoreService
+ * @param body
  */
-function buildDefaultTypeRegistryService() {
+function validateResponse(body) {
+    if (!body || !body.jwt || !body.baseUri) {
+        // wrapped the invocation in env conditional
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`Expected jwt info and baseUri to be present but instead got: ${JSON.stringify(body)}`);
+    }
+}
+/**
+ * Resolves Jwt token for SFAP by calling Aura action
+ * {@link JwtResolver} for platform SFAP
+ */
+const platformSfapJwtResolver = {
+    getJwt() {
+        return new Promise((resolve, reject) => {
+            dispatchAuraAction(`${SFAPController}.${SFAPJwtMethod}`, {}, defaultActionConfig)
+                .then((response) => {
+                const body = response.body;
+                if (process.env.NODE_ENV !== 'production') {
+                    validateResponse(body);
+                }
+                resolve({
+                    jwt: body.jwt,
+                    extraInfo: {
+                        baseUri: body.baseUri,
+                    },
+                });
+            })
+                .catch((error) => {
+                if (error instanceof Error) {
+                    reject(error.message);
+                    return;
+                }
+                // AuraFetchResponse errors
+                const { status } = error;
+                if (status !== HttpStatusCode.ServerError) {
+                    // ConnectInJavaError
+                    reject(error.body.message);
+                    return;
+                }
+                reject(error.body.error);
+            });
+        });
+    },
+};
+/**
+ * This hook is used to modify the resource request before it is sent to the server.
+ * SFAP uses extraInfo assocaiated JwtToken to update the baseUri for the resource request.
+ *
+ * @param resourceRequest
+ * @param jwtToken
+ * @returns resourceRequest with updated baseUri
+ */
+const modifySfapResourceRequest = function (resourceRequest, jwtToken) {
+    const { baseUri } = jwtToken.extraInfo;
     return {
-        type: 'typeRegistry',
-        version: '1.0',
-        service: new DefaultTypeRegistry(),
+        ...resourceRequest,
+        baseUri,
+    };
+};
+const sfapNetworkAdapter = buildJwtNetworkAdapter(platformSfapJwtResolver, modifySfapResourceRequest);
+const composedNetworkAdapter$1 = {
+    shouldHandleRequest(resourceRequest) {
+        return resourceRequest.baseUri === SALESFORCE_API_BASE_URI_FLAG;
+    },
+    adapter: sfapNetworkAdapter,
+};
+
+function buildJwtAuthorizedSfapFetchService() {
+    const jwtRepository = new JwtRepository();
+    const jwtManager = new JwtManager(jwtRepository, platformSfapJwtResolver);
+    const jwtRequestModifier = ({ baseUri }, [resource, request]) => {
+        if (typeof resource !== 'string') {
+            // istanbul ignore else: this will not be tested in NODE_ENV = production for test coverage
+            if (process.env.NODE_ENV !== 'production') {
+                throw new Error('JwtAuthorizedSfapFetchService expects a string path');
+            }
+        }
+        return [`${baseUri}${resource}`, request];
+    };
+    const jwtRequestHeaderInterceptor = buildJwtRequestHeaderInterceptor(jwtManager, jwtRequestModifier);
+    const jwtAuthorizedFetchService = buildFetchService({ request: [jwtRequestHeaderInterceptor] });
+    return {
+        ...jwtAuthorizedFetchService,
+        tags: { authenticationScopes: 'sfap_api' },
     };
 }
 
@@ -774,9 +1701,10 @@ class LexDefaultPage extends PredictivePrefetchPage {
 }
 
 class RecordHomePage extends PredictivePrefetchPage {
-    constructor(context, requestStrategies) {
+    constructor(context, requestStrategies, options) {
         super(context);
         this.requestStrategies = requestStrategies;
+        this.options = options;
         const { recordId: _, ...rest } = this.context;
         this.similarContext = {
             recordId: '*',
@@ -784,12 +1712,27 @@ class RecordHomePage extends PredictivePrefetchPage {
         };
     }
     buildSaveRequestData(request) {
+        const requestBuckets = [];
         const { adapterName } = request;
         const matchingRequestStrategy = this.requestStrategies[adapterName];
         if (matchingRequestStrategy === undefined) {
             return [];
         }
-        return matchingRequestStrategy.buildSaveRequestData(this.similarContext, this.context, request);
+        if (matchingRequestStrategy.isContextDependent(this.context, request)) {
+            requestBuckets.push({
+                context: this.similarContext,
+                request: matchingRequestStrategy.transformForSaveSimilarRequest(request),
+            });
+            // When `options.useExactMatchesPlus` is not enabled, we can save this request on the similar bucket only
+            if (!this.options.useExactMatchesPlus) {
+                return requestBuckets;
+            }
+        }
+        requestBuckets.push({
+            context: this.context,
+            request: matchingRequestStrategy.transformForSave(request),
+        });
+        return requestBuckets;
     }
     resolveSimilarRequest(similarRequest) {
         const { adapterName } = similarRequest;
@@ -823,18 +1766,34 @@ class RecordHomePage extends PredictivePrefetchPage {
 }
 
 class ObjectHomePage extends PredictivePrefetchPage {
-    constructor(context, requestStrategies) {
+    constructor(context, requestStrategies, options) {
         super(context);
         this.requestStrategies = requestStrategies;
+        this.options = options;
         this.similarContext = context;
     }
     buildSaveRequestData(request) {
+        const requestBuckets = [];
         const { adapterName } = request;
         const matchingRequestStrategy = this.requestStrategies[adapterName];
-        if (matchingRequestStrategy) {
-            return matchingRequestStrategy.buildSaveRequestData(this.similarContext, this.context, request);
+        if (matchingRequestStrategy === undefined) {
+            return [];
         }
-        return [];
+        if (matchingRequestStrategy.isContextDependent(this.context, request)) {
+            requestBuckets.push({
+                context: this.similarContext,
+                request: matchingRequestStrategy.transformForSaveSimilarRequest(request),
+            });
+            // When `options.useExactMatchesPlus` is not enabled, we can save this request on the similar bucket only
+            if (!this.options.useExactMatchesPlus) {
+                return requestBuckets;
+            }
+        }
+        requestBuckets.push({
+            context: this.context,
+            request: matchingRequestStrategy.transformForSave(request),
+        });
+        return requestBuckets;
     }
     // no similar requests between LVs
     resolveSimilarRequest(similarRequest) {
@@ -867,6 +1826,12 @@ class ObjectHomePage extends PredictivePrefetchPage {
                     recentListsOnly: true,
                 },
             },
+            {
+                adapterName: 'getListObjectInfo',
+                config: {
+                    objectApiName: objectApiName,
+                },
+            },
         ];
     }
     // Identifies a valid ObjectHomeContext
@@ -925,8 +1890,8 @@ const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = {
     },
 };
 
-const { create, keys } = Object;
-const { isArray } = Array;
+const { create, keys, hasOwnProperty } = Object;
+const { isArray, from } = Array;
 const { stringify } = JSON;
 
 /**
@@ -1411,7 +2376,7 @@ function setAuraInstrumentationHooks() {
     // 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) {
+    if (forceRecordTransactionsDisabled$1 === false) {
         ldsNetworkAdapterInstrument({
             getRecordAggregateResolve: (cb) => {
                 const { recordId, apiName } = cb();
@@ -1454,10 +2419,9 @@ function logCRUDLightningInteraction(eventSource, attributes) {
 const instrumentation = new Instrumentation();
 
 class ApplicationPredictivePrefetcher {
-    constructor(context, repository, requestRunner, options) {
+    constructor(context, repository, requestRunner) {
         this.repository = repository;
         this.requestRunner = requestRunner;
-        this.options = options;
         this.isRecording = false;
         this.queuedPredictionRequests = [];
         this._context = context;
@@ -1554,10 +2518,11 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
     // queue for pending prediction requests
     const requestQueue = [...requests];
     // Function to process the next request in the queue
-    const processNextRequest = async () => {
-        const timeInWaterfall = Date.now() - pageStartTime - 5; /* 5ms padding */
+    const processNextRequest = async (verifyPastTime = true) => {
+        const timeInWaterfall = Date.now() - pageStartTime;
         while (requestQueue.length > 0 &&
-            requestQueue[0].requestMetadata.requestTime < timeInWaterfall) {
+            verifyPastTime &&
+            requestQueue[0].requestMetadata.requestTime <= timeInWaterfall) {
             requestQueue.shift();
         }
         if (requestQueue.length > 0) {
@@ -1576,7 +2541,13 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
     const initialRequests = Math.min(concurrentRequestsLimit, requestQueue.length);
     const promises = [];
     for (let i = 0; i < initialRequests; i++) {
-        promises.push(processNextRequest());
+        // Initial requests should always execute, without verifying if they are past due.
+        // Reasoning:
+        //   It may be that one of the alwaysRequest (with 0 as start time) that is reduced
+        //   with the regular requests to make these to have 0 as the initial time in the waterfall.
+        //   Because predictions are behind an await (see W-16139321), it could be that when this code is evaluated
+        //   is already past time for the request.
+        promises.push(processNextRequest(false));
     }
     // Wait for all initial requests to complete
     await Promise.all(promises);
@@ -1585,58 +2556,73 @@ async function runRequestsWithLimit(requests, runner, concurrentRequestsLimit, p
 function isCmpDefsRequest({ request: { adapterName } }) {
     return adapterName === 'getComponentsDef';
 }
+function predictComponentDefs(cmpDefPredictions, requestRunner) {
+    const reducedPredictions = requestRunner.reduceRequests(cmpDefPredictions);
+    reducedPredictions.map((request) => requestRunner.runRequest(request.request));
+}
 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, options) {
-        super(context, repository, requestRunner, options);
+        super(context, repository, requestRunner);
         this.requestStrategies = requestStrategies;
+        this.options = options;
         this.page = this.getPage();
     }
     getPage() {
         if (RecordHomePage.handlesContext(this.context)) {
-            return new RecordHomePage(this.context, this.requestStrategies);
+            return new RecordHomePage(this.context, this.requestStrategies, this.options);
         }
         else if (ObjectHomePage.handlesContext(this.context)) {
-            return new ObjectHomePage(this.context, this.requestStrategies);
+            return new ObjectHomePage(this.context, this.requestStrategies, this.options);
         }
         return new LexDefaultPage(this.context);
     }
+    getAllPageRequests() {
+        const exactPageRequests = this.getExactPageRequest();
+        if (exactPageRequests.length > 0 && this.options.useExactMatchesPlus === true) {
+            return exactPageRequests;
+        }
+        const similarPageRequests = this.getSimilarPageRequests();
+        return [...exactPageRequests, ...similarPageRequests];
+    }
     async predict() {
-        const alwaysRequests = this.page.getAlwaysRunRequests();
-        // IMPORTANT: The `await` has no effect on this operation because `getSimilarPageRequests`
-        //            and `getExactPageRequest` are sync; however if removed, it will have a negative
-        //            effect when used with Aura Network: predictions will be boxcar'd, which likely will
-        //            result in a perf regression.
-        const similarPageRequests = await this.getSimilarPageRequests();
-        const exactPageRequests = await this.getExactPageRequest();
+        const pageRequests = this.getAllPageRequests();
+        // IMPORTANT: Because there's no way to diferentiate a cmpDef prediction from the page
+        //            requesting the cmpDef, we need to predict cmpDefs before we start watching
+        //            for predictions in the page. Having this code after an
+        //            await will make the predictions to be saved as predictions too.
+        predictComponentDefs(pageRequests.filter(isCmpDefsRequest), this.requestRunner);
+        // IMPORTANT: The `await` has no effect on this operation because `getAlwaysRunRequests`
+        //            is sync; however if removed, it will have a negative effect when used with
+        //            Aura Network: predictions will be boxcar'd, which likely will result in a
+        //            perf regression.
+        const alwaysRequests = await this.page.getAlwaysRunRequests();
         const alwaysRequestEntries = alwaysRequests.map((request) => {
             return {
                 request,
                 requestMetadata: { requestTime: 0 }, // ensures always requests are executed, and executed first.
             };
         });
+        const nonCmpDefPredictions = pageRequests.filter((r) => !isCmpDefsRequest(r));
         const reducedPredictions = this.requestRunner.reduceRequests([
-            ...exactPageRequests,
-            ...similarPageRequests,
+            ...nonCmpDefPredictions,
             ...alwaysRequestEntries,
         ]); // In future - remove alwaysRequestEntries when on OneStore
-        const nonCmpDefPredictions = reducedPredictions.filter((r) => !isCmpDefsRequest(r));
-        const cmpDefPredictions = reducedPredictions.filter(isCmpDefsRequest);
-        // Non CmpDefs requests are limited by AuraActions concurent inflight limit.
         // Always requests must go by themself - Some of them are essential to keep the page rendering at the beginning.
-        const predictedRequestsWithLimit = [...alwaysRequestEntries, ...nonCmpDefPredictions].sort((a, b) => a.requestMetadata.requestTime - b.requestMetadata.requestTime); // In future - choose sort algorithm via Gate?;
-        const inflightPredictionRequests = runRequestsWithLimit(predictedRequestsWithLimit, this.requestRunner, this.options.inflightRequestLimit, this.repository.pageStartTime);
-        const inflightCmpRequests = cmpDefPredictions.map((request) => this.requestRunner.runRequest(request.request));
-        return Promise.all([inflightPredictionRequests, ...inflightCmpRequests]).then();
+        const predictedRequestsWithLimit = [...alwaysRequestEntries, ...reducedPredictions].sort((a, b) => a.requestMetadata.requestTime - b.requestMetadata.requestTime); // In future - choose sort algorithm via Gate?;
+        await runRequestsWithLimit(predictedRequestsWithLimit, this.requestRunner, this.options.inflightRequestLimit, 
+        // `this.repository.pageStartTime` would be the correct here, but because
+        // the await hack (see W-16139321), there's some delta by the time this executed,
+        // on the other hand, when W-16139321 is fixed,
+        // when doing predict+watch, it could be (set in watch) repository.startTime is not set yet,
+        // Date.now() is a better alternative, that is correct, and works on both cases.
+        Date.now());
     }
 }
 
 // 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:
@@ -1660,11 +2646,11 @@ function stableJSONStringify(node) {
         return isFinite(node) ? '' + node : 'null';
     }
     if (typeof node !== 'object') {
-        return JSONStringify(node);
+        return stringify(node);
     }
     let i;
     let out;
-    if (ArrayIsArray$1(node)) {
+    if (isArray(node)) {
         out = '[';
         for (i = 0; i < node.length; i++) {
             if (i) {
@@ -1677,10 +2663,10 @@ function stableJSONStringify(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(node[key]);
         if (!value) {
             continue;
@@ -1688,7 +2674,7 @@ function stableJSONStringify(node) {
         if (out) {
             out += ',';
         }
-        out += JSONStringify(key) + ':' + value;
+        out += stringify(key) + ':' + value;
     }
     return '{' + out + '}';
 }
@@ -1704,8 +2690,8 @@ function deepEquals(objA, objB) {
     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);
+    const keysA = keys(objA).filter((key) => objA[key] !== undefined);
+    const keysB = keys(objB).filter((key) => objB[key] !== undefined);
     // If the objects do not have the same set of keys, they are not deeply equal
     if (keysA.length !== keysB.length)
         return false;
@@ -1778,25 +2764,12 @@ class PrefetchRepository {
         const page = this.getPage(key);
         if (page === undefined) {
             return [];
-        }
-        return page.requests;
-    }
-}
-
-class RequestStrategy {
-    transformForSave(request) {
-        return request;
-    }
-    reduce(requests) {
-        return requests;
+        }
+        return page.requests;
     }
 }
 
-class LuvioAdapterRequestStrategy extends RequestStrategy {
-    constructor(options = {}) {
-        super();
-        this.prefetcherOptions = options;
-    }
+class RequestStrategy {
     /**
      * Perform any transformations required to prepare the request for saving.
      *
@@ -1809,6 +2782,14 @@ class LuvioAdapterRequestStrategy extends RequestStrategy {
     transformForSave(request) {
         return request;
     }
+    /**
+     * Transforms the request for saving similar requests
+     * @param request Request to transform for saving similar requests
+     * @returns Transformed request
+     */
+    transformForSaveSimilarRequest(request) {
+        return this.transformForSave(request);
+    }
     /**
      * Filter requests to only those that are for this strategy.
      *
@@ -1887,58 +2868,6 @@ class LuvioAdapterRequestStrategy extends RequestStrategy {
     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 Request to build save request data for
-     * @returns Save request data
-     */
-    buildSaveRequestData(similarContext, context, request) {
-        const saveRequestDataBuckets = [];
-        if (this.isContextDependent(context, request)) {
-            saveRequestDataBuckets.push({
-                request: this.transformForSaveSimilarRequest(request),
-                context: similarContext,
-            });
-            const useSaveBuckets = this.prefetcherOptions && this.prefetcherOptions.useSaveBuckets;
-            if (!useSaveBuckets) {
-                return saveRequestDataBuckets;
-            }
-        }
-        saveRequestDataBuckets.push({
-            request: this.transformForSave(request),
-            context,
-        });
-        return saveRequestDataBuckets;
-    }
-    /**
-     * Transforms the request for saving similar requests
-     * @param request Request to transform for saving similar requests
-     * @returns Transformed request
-     */
-    transformForSaveSimilarRequest(request) {
-        return this.transformForSave(request);
-    }
-}
-
-/**
- * This is a base class for non-luvio request strategies, which needs to be treated as
- * LuvioAdapterRequestStrategy.
- */
-class ConfigBasedRequestStrategy extends LuvioAdapterRequestStrategy {
-    constructor() {
-        super(...arguments);
-        /**
-         * Config based request strategies are not based on Luvio factory, however
-         * the lex-predictive*, they all expect a LuvioAdapterRequestStrategy.
-         */
-        this.adapterFactory = (_luvio) => {
-            return (config) => this.executeWithConfig(config);
-        };
-    }
 }
 
 const noop = () => { };
@@ -2028,9 +2957,10 @@ function requestComponents(config) {
     try {
         for (let index = 0, n = config.length; index < n; index++) {
             const def = config[index];
-            if (!(def.includes('forceGenerated') ||
-                def.includes('one:onePreloads') ||
-                onePreloads.has(def))) {
+            if (def.startsWith('markup://') &&
+                !(def.includes('forceGenerated') ||
+                    def.includes('one:onePreloads') ||
+                    onePreloads.has(def))) {
                 getDefinition(def, noop);
             }
         }
@@ -2039,12 +2969,12 @@ function requestComponents(config) {
         // dismiss the error.
     }
 }
-class GetComponentsDefStrategy extends ConfigBasedRequestStrategy {
+class GetComponentsDefStrategy extends RequestStrategy {
     constructor() {
         super(...arguments);
         this.adapterName = 'getComponentsDef';
     }
-    executeWithConfig(config) {
+    execute(config) {
         return requestComponents(config);
     }
     buildConcreteRequest(similarRequest, _context) {
@@ -2052,18 +2982,11 @@ class GetComponentsDefStrategy extends ConfigBasedRequestStrategy {
             ...similarRequest,
         };
     }
-    buildSaveRequestData(similarContext, _context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context: similarContext,
-            },
-        ];
-    }
     transformForSave(request) {
+        const normalizedConfig = (request.config || []).map((def) => def.indexOf('://') === -1 ? 'markup://' + def : def);
         return {
             ...request,
-            config: request.config || [],
+            config: normalizedConfig,
         };
     }
     canCombine() {
@@ -2074,6 +2997,26 @@ class GetComponentsDefStrategy extends ConfigBasedRequestStrategy {
         reqB.forEach((c) => result.add(c));
         return [...result];
     }
+    isContextDependent(_context, _request) {
+        return true;
+    }
+}
+
+const LDS_PDL_CMP_IDENTIFIER = 'lds:pdl';
+const DEFAULT_RESOURCE_CONTEXT = {
+    sourceContext: { tagName: LDS_PDL_CMP_IDENTIFIER },
+};
+class LuvioAdapterRequestStrategy extends RequestStrategy {
+    constructor(luvio) {
+        super();
+        this.luvio = luvio;
+    }
+    execute(config, requestContext) {
+        return this.adapterFactory(this.luvio)(config, {
+            ...DEFAULT_RESOURCE_CONTEXT,
+            ...requestContext,
+        });
+    }
 }
 
 function normalizeRecordIds$1(recordIds) {
@@ -2231,7 +3174,7 @@ class GetRecordsRequestStrategy extends LuvioAdapterRequestStrategy {
 }
 
 function normalizeRecordIds(recordIds) {
-    if (!ArrayIsArray$1(recordIds)) {
+    if (!isArray(recordIds)) {
         return [recordIds];
     }
     return recordIds;
@@ -2240,7 +3183,7 @@ function normalizeApiNames(apiNames) {
     if (apiNames === undefined || apiNames === null) {
         return [];
     }
-    return ArrayIsArray$1(apiNames) ? apiNames : [apiNames];
+    return isArray(apiNames) ? apiNames : [apiNames];
 }
 class GetRecordActionsRequestStrategy extends LuvioAdapterRequestStrategy {
     constructor() {
@@ -2358,14 +3301,6 @@ class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy {
         }
         return reducedRequests;
     }
-    buildSaveRequestData(similarContext, context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context,
-            },
-        ];
-    }
 }
 
 class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
@@ -2415,11 +3350,9 @@ class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
     }
 }
 
-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;
+        return rlReq.relatedListId !== undefined && keys(rlReq).length === 1;
     });
 }
 class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy {
@@ -2463,7 +3396,7 @@ class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy
      */
     canCombine(reqA, reqB) {
         const [recordIdA, recordIdB] = [reqA.recordIds, reqB.recordIds].map((recordIds) => {
-            return ArrayIsArray(recordIds)
+            return isArray(recordIds)
                 ? recordIds.length === 1
                     ? recordIds[0]
                     : null
@@ -2481,7 +3414,7 @@ class GetRelatedListsActionsRequestStrategy extends LuvioAdapterRequestStrategy
         });
         return {
             recordIds: reqA.recordIds,
-            relatedListsActionParameters: ArrayFrom(relatedListsIncluded).map((relatedListId) => ({
+            relatedListsActionParameters: from(relatedListsIncluded).map((relatedListId) => ({
                 relatedListId,
             })),
         };
@@ -2637,14 +3570,6 @@ class GetApexRequestStrategy extends LuvioAdapterRequestStrategy {
     buildConcreteRequest(similarRequest) {
         return similarRequest;
     }
-    buildSaveRequestData(_similarContext, context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context,
-            },
-        ];
-    }
 }
 
 const GET_LIST_INFO_BY_NAME_ADAPTER_NAME = 'getListInfoByName';
@@ -2667,14 +3592,6 @@ class GetListInfoByNameRequestStrategy extends LuvioAdapterRequestStrategy {
             },
         };
     }
-    buildSaveRequestData(_similarContext, context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context,
-            },
-        ];
-    }
     canCombine(reqA, reqB) {
         return (reqA.objectApiName === reqB.objectApiName &&
             reqA.listViewApiName === reqB.listViewApiName);
@@ -2704,14 +3621,6 @@ class GetListInfosByObjectNameRequestStrategy extends LuvioAdapterRequestStrateg
             },
         };
     }
-    buildSaveRequestData(_similarContext, context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context,
-            },
-        ];
-    }
     canCombine(reqA, reqB) {
         return (reqA.objectApiName === reqB.objectApiName &&
             reqA.q === reqB.q &&
@@ -2753,36 +3662,50 @@ class GetListRecordsByNameRequestStrategy extends LuvioAdapterRequestStrategy {
         // to build the key should solve this issue till then we can't move fields into optional fields
         return request;
     }
-    buildSaveRequestData(_similarContext, context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context,
+}
+
+const GET_LIST_OBJECT_INFO_ADAPTER_NAME = 'getListObjectInfo';
+class GetListObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
+    constructor() {
+        super(...arguments);
+        this.adapterName = GET_LIST_OBJECT_INFO_ADAPTER_NAME;
+        this.adapterFactory = getListObjectInfoAdapterFactory;
+    }
+    buildConcreteRequest(similarRequest) {
+        return similarRequest;
+    }
+    transformForSave(request) {
+        return {
+            ...request,
+            config: {
+                ...request.config,
+                // (!): if we are saving this request is because the adapter already verified is valid.
+                objectApiName: coerceObjectId(request.config.objectApiName),
             },
-        ];
+        };
     }
 }
 
-const LDS_PDL_CMP_IDENTIFIER = 'lds:pdl';
 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({}),
-            getListInfoByName: new GetListInfoByNameRequestStrategy({}),
-            getListRecordsByName: new GetListRecordsByNameRequestStrategy({}),
-            getApex: new GetApexRequestStrategy({}),
-            getComponentsDef: new GetComponentsDefStrategy({}),
-            getListInfosByObjectName: new GetListInfosByObjectNameRequestStrategy({}),
+            getRecord: new GetRecordRequestStrategy(luvio),
+            getRecords: new GetRecordsRequestStrategy(luvio),
+            getRecordActions: new GetRecordActionsRequestStrategy(luvio),
+            getRecordAvatars: new GetRecordAvatarsRequestStrategy(luvio),
+            getObjectInfo: new GetObjectInfoRequestStrategy(luvio),
+            getObjectInfos: new GetObjectInfosRequestStrategy(luvio),
+            getRelatedListsActions: new GetRelatedListsActionsRequestStrategy(luvio),
+            getRelatedListInfoBatch: new GetRelatedListInfoBatchRequestStrategy(luvio),
+            getRelatedListRecords: new GetRelatedListRecordsRequestStrategy(luvio),
+            getRelatedListRecordsBatch: new GetRelatedListRecordsBatchRequestStrategy(luvio),
+            getListInfoByName: new GetListInfoByNameRequestStrategy(luvio),
+            getListRecordsByName: new GetListRecordsByNameRequestStrategy(luvio),
+            getApex: new GetApexRequestStrategy(luvio),
+            getComponentsDef: new GetComponentsDefStrategy(),
+            getListInfosByObjectName: new GetListInfosByObjectNameRequestStrategy(luvio),
+            getListObjectInfo: new GetListObjectInfoRequestStrategy(luvio),
         };
     }
     reduceRequests(requests) {
@@ -2792,10 +3715,7 @@ class LexRequestRunner {
     }
     runRequest(request) {
         if (request.adapterName in this.requestStrategies) {
-            const adapterFactory = this.requestStrategies[request.adapterName].adapterFactory;
-            return Promise.resolve(adapterFactory(this.luvio)(request.config, {
-                sourceContext: { tagName: LDS_PDL_CMP_IDENTIFIER },
-            })).then();
+            return Promise.resolve(this.requestStrategies[request.adapterName].execute(request.config)).then();
         }
         return Promise.resolve(undefined);
     }
@@ -2814,13 +3734,12 @@ class InMemoryPrefetchStorage {
     }
 }
 
-const { keys: ObjectKeys } = Object;
 const DEFAULT_STORAGE_OPTIONS = {
     name: 'ldsPredictiveLoading',
     persistent: true,
     secure: true,
     maxSize: 7 * 1024 * 1024,
-    expiration: 12 * 60 * 60,
+    expiration: 5 * 24 * 60 * 60,
     clearOnInit: false,
     debugLogging: false,
     version: 3,
@@ -2853,7 +3772,7 @@ class AuraPrefetchStorage {
          *    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]));
+            keys(results).forEach((key) => this.inMemoryStorage.set(key, results[key]));
         });
     }
     set(key, value) {
@@ -2889,84 +3808,308 @@ function buildComposableNetworkAdapter(composedAdapters) {
     };
 }
 
-const SALESFORCE_API_BASE_URI_FLAG = 'api.salesforce.com';
-const SFAPController = 'SalesforceApiPlatformController';
-const SFAPJwtMethod = 'getSFAPLightningJwtService';
 /**
- * We expect jwt info and baseUri to be present in the response.
- *
- * @param body
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
  */
-function validateResponse(body) {
-    if (!body || !body.jwt || !body.baseUri) {
-        // wrapped the invocation in env conditional
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error(`Expected jwt info and baseUri to be present but instead got: ${JSON.stringify(body)}`);
-    }
-}
+
+/*
+ *  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.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+var EnvironmentSettings;
+(function (EnvironmentSettings) {
+    EnvironmentSettings["ForceRecordTransactionsDisabled"] = "forceRecordTransactionsDisabled";
+})(EnvironmentSettings || (EnvironmentSettings = {}));
+const GATE_FORCE_RECORD_TRANSACTIONS_DISABLED = '$Browser.S1Features.forceRecordTransactionsDisabled';
+const supportedEnvironmentSettings = {
+    [EnvironmentSettings.ForceRecordTransactionsDisabled]: GATE_FORCE_RECORD_TRANSACTIONS_DISABLED,
+};
 /**
- * Resolves Jwt token for SFAP by calling Aura action
- * {@link JwtResolver} for platform SFAP
+ * Returns aura configuration settings. Used to check gate/perm statuses.
+ * @param name Name of the setting to check.
+ * @returns Value of the setting, or undefined if $A is not available.
  */
-const platformSfapJwtResolver = {
-    getJwt() {
-        return new Promise((resolve, reject) => {
-            dispatchAuraAction(`${SFAPController}.${SFAPJwtMethod}`, {}, defaultActionConfig)
-                .then((response) => {
-                const body = response.body;
-                if (process.env.NODE_ENV !== 'production') {
-                    validateResponse(body);
-                }
-                resolve({
-                    jwt: body.jwt,
-                    extraInfo: {
-                        baseUri: body.baseUri,
-                    },
-                });
-            })
-                .catch((error) => {
-                if (error instanceof Error) {
-                    reject(error.message);
-                    return;
-                }
-                // AuraFetchResponse errors
-                const { status } = error;
-                if (status !== HttpStatusCode.ServerError) {
-                    // ConnectInJavaError
-                    reject(error.body.message);
-                    return;
+function getEnvironmentSetting(name) {
+    if (typeof window === 'undefined') {
+        // server environment i.e. SSR in LWR
+        return undefined;
+    }
+    const environmentSetting = supportedEnvironmentSettings[name];
+    if (typeof window.$A !== 'undefined' && environmentSetting !== undefined) {
+        return window.$A.get(environmentSetting);
+    }
+    return undefined;
+}
+// version: 1.304.0-d87b57badb
+
+const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
+//TODO: Some duplication here that can be most likely moved to a util class
+const NO_RECORD_ID_204 = '204_NO_RECORD_ID';
+const NO_RECORD_TYPE_204 = '204_NO_RECORD_TYPE';
+let crudInstrumentationCallbacks = {};
+let crudRLInstrumentationCallbacks = {};
+if (forceRecordTransactionsDisabled === false) {
+    // Record callbacks
+    crudInstrumentationCallbacks = {
+        createRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.CREATE, {
+                // recordId: config.params.recordInput.apiName, // seems wrong?
+                recordId: config.params.recordId || NO_RECORD_ID_204,
+                state: CrudEventState.ERROR,
+            });
+        },
+        createRecordResolveFunction: (config) => {
+            const recordId = config.body ? config.body.id : NO_RECORD_ID_204;
+            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
+            logCRUDLightningInteraction(CrudEventType.CREATE, {
+                recordId,
+                recordType,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        deleteRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.DELETE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        deleteRecordResolveFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.DELETE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        // These should be handled by the network adapater?
+        // getRecordAggregateRejectFunction: (config: InstrumentationRejectConfig) => {
+        //     logCRUDLightningInteraction(CrudEventType.READ, {
+        //         recordId: config.params.recordId,
+        //         state: CrudEventState.ERROR,
+        //     });
+        // },
+        // getRecordAggregateResolveFunction: (config: InstrumentationResolveConfig) => {
+        //     logCRUDLightningInteraction(CrudEventType.READ, {
+        //         recordId: config.params.recordId,
+        //         recordType: config.body.apiName,
+        //         state: CrudEventState.SUCCESS,
+        //     });
+        // },
+        getRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READ, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRecordResolveFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READ, {
+                recordId: config.params.recordId,
+                recordType: config.body.apiName,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+        updateRecordRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.UPDATE, {
+                recordId: config.params.recordId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        updateRecordResolveFunction: (config) => {
+            const recordType = config.body ? config.body.apiName : NO_RECORD_TYPE_204;
+            logCRUDLightningInteraction(CrudEventType.UPDATE, {
+                recordId: config.params.recordId,
+                recordType,
+                state: CrudEventState.SUCCESS,
+            });
+        },
+    };
+    // Related list callbacks
+    crudRLInstrumentationCallbacks = {
+        getRelatedListRecordsRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READS, {
+                parentRecordId: config.params.parentRecordId,
+                relatedListId: config.params.relatedListId,
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRelatedListRecordsResolveFunction: (config) => {
+            logGetRelatedListRecordsInteraction(config.body);
+        },
+        getRelatedListRecordsBatchRejectFunction: (config) => {
+            logCRUDLightningInteraction(CrudEventType.READS, {
+                parentRecordId: config.params.parentRecordId,
+                relatedListIds: config.params.relatedListParameters.map((entry) => entry.relatedListId),
+                state: CrudEventState.ERROR,
+            });
+        },
+        getRelatedListRecordsBatchResolveFunction: (config) => {
+            config.body.results.forEach((res) => {
+                // Log for each RL that was returned from batch endpoint
+                if (res.statusCode === 200) {
+                    logGetRelatedListRecordsInteraction(res.result);
                 }
-                reject(error.body.error);
             });
-        });
+        },
+    };
+}
+// Helper function copied from ui-api
+function logGetRelatedListRecordsInteraction(body) {
+    const records = body.records;
+    // Don't log anything if the related list has no records.
+    if (records.length === 0) {
+        return;
+    }
+    const recordIds = records.map((record) => {
+        return record.id;
+    });
+    /**
+     *  In almost every case - the relatedList records will all be of the same apiName, but there is an edge case for
+        Activities entity that could return Events & Tasks- so handle that case by returning a joined string.
+        ADS Implementation only looks at the first record returned to determine the apiName.
+        See force/recordLibrary/recordMetricsPlugin.js _getRecordType method.
+     */
+    logCRUDLightningInteraction(CrudEventType.READS, {
+        parentRecordId: body.listReference.inContextOfRecordId,
+        relatedListId: body.listReference.relatedListId,
+        recordIds,
+        recordType: body.records[0].apiName,
+        state: CrudEventState.SUCCESS,
+    });
+}
+const crudInstrumentationConfig = {
+    records: {
+        post: {
+            rejectFn: crudInstrumentationCallbacks.createRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.createRecordResolveFunction,
+        },
+        get: {
+            rejectFn: crudInstrumentationCallbacks.getRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.getRecordResolveFunction,
+        },
+        patch: {
+            rejectFn: crudInstrumentationCallbacks.updateRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.updateRecordResolveFunction,
+        },
+        delete: {
+            rejectFn: crudInstrumentationCallbacks.deleteRecordRejectFunction,
+            resolveFn: crudInstrumentationCallbacks.deleteRecordResolveFunction,
+        },
+    },
+    relatedListRecords: {
+        post: {
+            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsRejectFunction,
+            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsResolveFunction,
+        },
+    },
+    relatedListRecordsBatch: {
+        post: {
+            rejectFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchRejectFunction,
+            resolveFn: crudRLInstrumentationCallbacks.getRelatedListRecordsBatchResolveFunction,
+        },
     },
 };
-/**
- * This hook is used to modify the resource request before it is sent to the server.
- * SFAP uses extraInfo assocaiated JwtToken to update the baseUri for the resource request.
- *
- * @param resourceRequest
- * @param jwtToken
- * @returns resourceRequest with updated baseUri
- */
-const modifySfapResourceRequest = function (resourceRequest, jwtToken) {
-    const { baseUri } = jwtToken.extraInfo;
+function checkAndLogCrudInteraction(request, isResolve, error, response) {
+    let configPath;
+    const baseUrl = `${request.baseUri}${request.basePath}`;
+    if (baseUrl.startsWith(UIAPI_RECORDS_PATH)) {
+        configPath = crudInstrumentationConfig['records']; // maybe use a constant for this
+    }
+    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_BATCH_PATH)) {
+        configPath = crudInstrumentationConfig['relatedListRecordsBatch'];
+    }
+    else if (baseUrl.startsWith(UIAPI_RELATED_LIST_RECORDS_PATH)) {
+        configPath = crudInstrumentationConfig['relatedListRecords'];
+    }
+    if (configPath) {
+        const crudCallbacks = configPath[request.method];
+        if (crudCallbacks) {
+            if (isResolve && crudCallbacks.resolveFn) {
+                crudCallbacks.resolveFn(setResolveConfig(request, response));
+            }
+            else if (crudCallbacks.rejectFn) {
+                crudCallbacks.rejectFn(setRejectConfig(request, error));
+            }
+        }
+    }
+}
+function setResolveConfig(request, response) {
+    const responseBody = response ? response.body : {};
+    const urlParams = request.urlParams || {};
+    return {
+        body: responseBody,
+        params: {
+            recordId: urlParams.recordId,
+        },
+    };
+}
+function setRejectConfig(request, error) {
+    const requestBody = request.body || {};
+    const urlParams = request.urlParams || {};
+    return {
+        err: error,
+        params: {
+            recordId: urlParams.recordId,
+            // pass these in even if they're undefined
+            parentRecordId: urlParams.parentRecordId,
+            relatedListId: urlParams.relatedListId,
+            relatedListParameters: requestBody.relatedListParameters,
+        },
+    };
+}
+
+const UIAPI_FAMILY = '/ui-api/'; // swap this to an allowlist per family (or build it off package.jsons?)
+// Denylist
+const PRIVATE_RESOURCES = ['record-avatars', 'user-state']; // These resources have Connect client filters, must be requested through UiTier :eyeroll:
+function isPrivatePath(basePath) {
+    return PRIVATE_RESOURCES.some((privateResource) => basePath.includes(privateResource));
+}
+const modifyLexResourceRequest = function (resourceRequest, jwtToken) {
+    const jwtBaseUri = jwtToken.decodedInfo.iss;
     return {
         ...resourceRequest,
-        baseUri,
+        baseUri: jwtBaseUri + resourceRequest.baseUri,
     };
 };
-const sfapNetworkAdapter = buildJwtNetworkAdapter(platformSfapJwtResolver, modifySfapResourceRequest);
-const composedNetworkAdapter$1 = {
+const requestTracker = {
+    registerHandler: (request, name, loadedCheck) => {
+        ThirdPartyTracker.registerHandler(request, name, loadedCheck);
+    },
+    markFinished: (request) => {
+        ThirdPartyTracker.markLoaded(request);
+    },
+};
+const requestLogger = {
+    resolve: (request, response = {}) => {
+        checkAndLogCrudInteraction(request, true, null, response);
+    },
+    reject: (request, error) => {
+        checkAndLogCrudInteraction(request, false, error);
+    },
+};
+const composedFetchNetworkAdapter = {
     shouldHandleRequest(resourceRequest) {
-        return resourceRequest.baseUri === SALESFORCE_API_BASE_URI_FLAG;
+        return (resourceRequest.basePath.startsWith(UIAPI_FAMILY) &&
+            !isPrivatePath(resourceRequest.basePath));
     },
-    adapter: sfapNetworkAdapter,
+    adapter: setupLexJwtNetworkAdapter(auraNetworkAdapter, modifyLexResourceRequest, requestTracker, requestLogger),
 };
 
+function getComposedAdapters() {
+    const composedAdapters = [
+        composedNetworkAdapter$1, // SFAP adapter
+    ];
+    if (useHttpInsteadAuraTransport.isOpen({ fallback: false })) {
+        composedAdapters.push(composedFetchNetworkAdapter); // UIAPI Fetch adapter?
+    }
+    return composedAdapters;
+}
 const composedNetworkAdapter = buildComposableNetworkAdapter([
-    composedNetworkAdapter$1,
-    // The  aura network adapter must be the default.
+    ...getComposedAdapters(),
+    // The aura network adapter must be the default.
     {
         shouldHandleRequest() {
             return true;
@@ -3026,64 +4169,74 @@ function setupQueryEvaluators(luvio, store) {
 }
 let __lexPrefetcher;
 const HARDCODED_REQUEST_LIMIT = 9;
+function getInflightRequestLimit() {
+    try {
+        return window['$A'].clientService.maxAllowedParallelXHRCounts() - 3;
+    }
+    catch (e) {
+        return HARDCODED_REQUEST_LIMIT;
+    }
+}
 function setupPredictivePrefetcher(luvio) {
     const storage = buildAuraPrefetchStorage();
     const repository = new PrefetchRepository(storage);
     const requestRunner = new LexRequestRunner(luvio);
     const inflightRequestLimit = applyPredictionRequestLimit.isOpen({ fallback: false })
-        ? HARDCODED_REQUEST_LIMIT
+        ? getInflightRequestLimit()
         : 1000;
-    const useSaveBuckets = useExactMatchesPlus.isOpen({ fallback: false });
+    const useExactMatchesPlus = useExactMatchesPlusGate.isOpen({ fallback: false });
     const prefetcherOptions = {
         inflightRequestLimit,
-        useSaveBuckets,
+        useExactMatchesPlus,
     };
     const prefetcher = new LexPredictivePrefetcher({ context: 'unknown' }, repository, requestRunner, {
-        getRecord: new GetRecordRequestStrategy(prefetcherOptions),
-        getRecords: new GetRecordsRequestStrategy(prefetcherOptions),
-        getRecordActions: new GetRecordActionsRequestStrategy(prefetcherOptions),
-        getRecordAvatars: new GetRecordAvatarsRequestStrategy(prefetcherOptions),
-        getObjectInfo: new GetObjectInfoRequestStrategy(prefetcherOptions),
-        getObjectInfos: new GetObjectInfosRequestStrategy(prefetcherOptions),
-        getRelatedListsActions: new GetRelatedListsActionsRequestStrategy(prefetcherOptions),
-        getRelatedListRecords: new GetRelatedListRecordsRequestStrategy(prefetcherOptions),
-        getRelatedListRecordsBatch: new GetRelatedListRecordsBatchRequestStrategy(prefetcherOptions),
-        getRelatedListInfoBatch: new GetRelatedListInfoBatchRequestStrategy(prefetcherOptions),
-        getListInfoByName: new GetListInfoByNameRequestStrategy(prefetcherOptions),
-        getListRecordsByName: new GetListRecordsByNameRequestStrategy(prefetcherOptions),
-        getApexStrategy: new GetApexRequestStrategy(prefetcherOptions),
-        getComponentsDef: new GetComponentsDefStrategy(prefetcherOptions),
-        getListInfosByObjectName: new GetListInfosByObjectNameRequestStrategy(prefetcherOptions),
+        getRecord: new GetRecordRequestStrategy(luvio),
+        getRecords: new GetRecordsRequestStrategy(luvio),
+        getRecordActions: new GetRecordActionsRequestStrategy(luvio),
+        getRecordAvatars: new GetRecordAvatarsRequestStrategy(luvio),
+        getObjectInfo: new GetObjectInfoRequestStrategy(luvio),
+        getObjectInfos: new GetObjectInfosRequestStrategy(luvio),
+        getRelatedListsActions: new GetRelatedListsActionsRequestStrategy(luvio),
+        getRelatedListRecords: new GetRelatedListRecordsRequestStrategy(luvio),
+        getRelatedListRecordsBatch: new GetRelatedListRecordsBatchRequestStrategy(luvio),
+        getRelatedListInfoBatch: new GetRelatedListInfoBatchRequestStrategy(luvio),
+        getListInfoByName: new GetListInfoByNameRequestStrategy(luvio),
+        getListRecordsByName: new GetListRecordsByNameRequestStrategy(luvio),
+        getApex: new GetApexRequestStrategy(luvio),
+        getComponentsDef: new GetComponentsDefStrategy(),
+        getListInfosByObjectName: new GetListInfosByObjectNameRequestStrategy(luvio),
+        getListObjectInfo: new GetListObjectInfoRequestStrategy(luvio),
     }, prefetcherOptions);
     registerPrefetcher(luvio, prefetcher);
     if (useApexPredictions.isOpen({ fallback: false })) {
         registerPrefetcher$1(luvio, prefetcher);
     }
     __lexPrefetcher = prefetcher;
-    if (useCmpDefPredictions.isOpen({ fallback: false })) {
-        window['$A'].installOverride('ComponentDefLoader.loadingComplete', (...args) => {
-            /**
-             * To install an override (taken from the Aura.Utils.Override):
-             *
-             * The function supplied should have the following code in it:
-             * ------
-             *  var config = Array.prototype.shift.apply(arguments);
-             *  var ret = config["fn"].apply(config["scope"], arguments);
-             *  return ret
-             * ------
-             */
-            const config = Array.prototype.shift.apply(args);
-            const ret = config['fn'].apply(config['scope'], args);
-            const [hasErrors, descriptors] = args;
-            if (!hasErrors && Array.isArray(descriptors) && descriptors.length > 0) {
-                __lexPrefetcher.saveRequest({
-                    adapterName: 'getComponentsDef',
-                    config: descriptors,
-                });
-            }
-            return ret;
+}
+function loadComponentsDefStartedOverride(...args) {
+    /**
+     * To install an override (taken from the Aura.Utils.Override):
+     *
+     * The function supplied should have the following code in it:
+     * ------
+     *  var config = Array.prototype.shift.apply(arguments);
+     *  var ret = config["fn"].apply(config["scope"], arguments);
+     *  return ret
+     * ------
+     */
+    const config = Array.prototype.shift.apply(args);
+    const ret = config['fn'].apply(config['scope'], args);
+    try {
+        const defs = keys(args[0] || {});
+        __lexPrefetcher.saveRequest({
+            adapterName: 'getComponentsDef',
+            config: defs,
         });
     }
+    catch (e) {
+        // dismiss any error, the activity will log it.
+    }
+    return ret;
 }
 /**
  * @typedef {Object} RecordHomePageContext
@@ -3124,8 +4277,14 @@ function buildPredictorForContext(context) {
         watchPageLoadForPredictions() {
             // This chunk tells the prefetcher to receive events, send off any predictions we have from previous loads, then setup idle detection to stop predicting.
             __lexPrefetcher.startRecording();
+            if (useCmpDefPredictions.isOpen({ fallback: false })) {
+                window['$A'].installOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
+            }
             onIdleDetected(() => {
                 __lexPrefetcher.stopRecording();
+                if (useCmpDefPredictions.isOpen({ fallback: false })) {
+                    window['$A'].uninstallOverride('ComponentService.loadComponentDefsStarted', loadComponentsDefStartedOverride);
+                }
             });
         },
         runPredictions() {
@@ -3184,7 +4343,15 @@ function initializeOneStore() {
             defaultCachePolicyName: 'cache-then-network',
         },
     };
+    const jwtAuthorizedSfapFetchService = buildJwtAuthorizedSfapFetchService();
+    // TODO [W-1234567]: Export descriptor builder for o11y and noop instrumentaiton
+    const instrumentationServiceDescriptor = {
+        type: 'instrumentation',
+        version: '1.0',
+        service: buildNoopInstrumentationService(),
+    };
     const services = [
+        jwtAuthorizedSfapFetchService,
         keySubscriptionServiceDescriptor,
         metadataRepositoryServiceDescriptor,
         storeServiceDescriptor,
@@ -3193,6 +4360,15 @@ function initializeOneStore() {
         buildDefaultTypeRegistryService(),
         buildAuraNetworkService(),
         buildInMemoryCacheInclusionPolicyService(),
+        buildAuraNetworkCommandBaseClassService(),
+        buildFetchNetworkCommandBaseClassService(),
+        buildNetworkCommandBaseClassService(),
+        buildStreamingCommandBaseClassService(),
+        buildSSECommandBaseClassService(),
+        instrumentationServiceDescriptor,
+        buildInstrumentCommandServiceDescriptor({
+            instrumentation: instrumentationServiceDescriptor.service,
+        }),
     ];
     serviceBroker.publish(services);
 }
@@ -3221,4 +4397,4 @@ function ldsEngineCreator() {
 }
 
 export { buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore };
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550