@salesforce/lds-runtime-aura 1.301.0 → 1.303.0

package/dist/ldsEngineCreator.js

@@ -19,23 +19,437 @@ 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 } from 'force/ldsNetworkFetchWithJwt';
+import auraNetworkAdapter, { dispatchAuraAction, defaultActionConfig, instrument as instrument$1, forceRecordTransactionsDisabled, ldsNetworkAdapterInstrument } 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 { 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.
@@ -274,66 +688,9 @@ class TTLFilteredStore {
  */
 
 
-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'));
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
-/**
- * Implementation of CacheInclusionPolicy that uses a single level, in memory,
- * synchronous L1 cache.
+ * Implementation of CacheInclusionPolicy that uses a single level, in memory,
+ * synchronous L1 cache.
  */
 class InMemoryCacheInclusionPolicy {
     /**
@@ -343,7 +700,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 +708,7 @@ class InMemoryCacheInclusionPolicy {
     write(options) {
         const { l1, writeToL1 } = options;
         writeToL1(l1);
-        return resolvedPromiseLike$1(undefined);
+        return resolvedPromiseLike(undefined);
     }
 }
 /**
@@ -374,32 +731,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 +748,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 +784,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,63 +1065,6 @@ function buildKeyBasedRequestDedupeService() {
  */
 
 
-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'));
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
 /**
  * A simple implementation of KeyKeySubscriptionService.
  */
@@ -734,15 +1138,536 @@ class DefaultTypeRegistry {
     }
 }
 /**
- * Constructs an in-memory implementation of StoreService.
+ * Constructs an in-memory implementation of StoreService.
+ *
+ * @returns in-memory implementation of StoreService
+ */
+function buildDefaultTypeRegistryService() {
+    return {
+        type: 'typeRegistry',
+        version: '1.0',
+        service: new DefaultTypeRegistry(),
+    };
+}
+
+/**
+ * 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;
+    }
+}
+
+/**
+ * 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();
+}
+/**
+ * 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.
+ */
+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;
+    }
+    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.observers = this.observers.filter((observer) => observer !== cb);
+        };
+    }
+    /**
+     * Clear the timeout handler.
+     */
+    clearTimeoutHandler() {
+        if (this.timeoutHandler !== undefined) {
+            clearTimeout(this.timeoutHandler);
+        }
+    }
+    /**
+     * 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);
+            }
+        });
+    }
+}
+
+/**
+ * JwtManager class.
+ * It provides methods for managing JWT (Json Web Token), such as retrieving and refreshing.
+ *
+ * @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.
+ */
+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;
+    }
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+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));
+        },
+    };
+}
+
+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);
+        }
+        // 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);
+        }
+        // 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 [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';
+/**
+ * We expect jwt info and baseUri to be present in the response.
+ *
+ * @param body
+ */
+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.
  *
- * @returns in-memory implementation of StoreService
+ * @param resourceRequest
+ * @param jwtToken
+ * @returns resourceRequest with updated baseUri
  */
-function buildDefaultTypeRegistryService() {
+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 +1699,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 +1710,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 +1764,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 +1824,12 @@ class ObjectHomePage extends PredictivePrefetchPage {
                     recentListsOnly: true,
                 },
             },
+            {
+                adapterName: 'getListObjectInfo',
+                config: {
+                    objectApiName: objectApiName,
+                },
+            },
         ];
     }
     // Identifies a valid ObjectHomeContext
@@ -1454,10 +2417,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;
@@ -1590,27 +2552,35 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
     // 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();
+        // IMPORTANT: The `await` has no effect on this operation because `getAllPageRequests`
+        //            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 pageRequests = await this.getAllPageRequests();
         const alwaysRequestEntries = alwaysRequests.map((request) => {
             return {
                 request,
@@ -1618,8 +2588,7 @@ class LexPredictivePrefetcher extends ApplicationPredictivePrefetcher {
             };
         });
         const reducedPredictions = this.requestRunner.reduceRequests([
-            ...exactPageRequests,
-            ...similarPageRequests,
+            ...pageRequests,
             ...alwaysRequestEntries,
         ]); // In future - remove alwaysRequestEntries when on OneStore
         const nonCmpDefPredictions = reducedPredictions.filter((r) => !isCmpDefsRequest(r));
@@ -1784,19 +2753,6 @@ class PrefetchRepository {
 }
 
 class RequestStrategy {
-    transformForSave(request) {
-        return request;
-    }
-    reduce(requests) {
-        return requests;
-    }
-}
-
-class LuvioAdapterRequestStrategy extends RequestStrategy {
-    constructor(options = {}) {
-        super();
-        this.prefetcherOptions = options;
-    }
     /**
      * Perform any transformations required to prepare the request for saving.
      *
@@ -1809,6 +2765,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 +2851,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 = () => { };
@@ -2039,12 +2951,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,14 +2964,6 @@ class GetComponentsDefStrategy extends ConfigBasedRequestStrategy {
             ...similarRequest,
         };
     }
-    buildSaveRequestData(similarContext, _context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context: similarContext,
-            },
-        ];
-    }
     transformForSave(request) {
         return {
             ...request,
@@ -2074,6 +2978,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) {
@@ -2358,14 +3282,6 @@ class GetObjectInfosRequestStrategy extends LuvioAdapterRequestStrategy {
         }
         return reducedRequests;
     }
-    buildSaveRequestData(similarContext, context, request) {
-        return [
-            {
-                request: this.transformForSave(request),
-                context,
-            },
-        ];
-    }
 }
 
 class GetObjectInfoRequestStrategy extends LuvioAdapterRequestStrategy {
@@ -2637,14 +3553,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 +3575,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 +3604,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 +3645,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 +3698,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);
     }
@@ -2820,7 +3723,7 @@ const DEFAULT_STORAGE_OPTIONS = {
     persistent: true,
     secure: true,
     maxSize: 7 * 1024 * 1024,
-    expiration: 12 * 60 * 60,
+    expiration: 5 * 24 * 60 * 60,
     clearOnInit: false,
     debugLogging: false,
     version: 3,
@@ -2889,81 +3792,6 @@ 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
- */
-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 {
-        ...resourceRequest,
-        baseUri,
-    };
-};
-const sfapNetworkAdapter = buildJwtNetworkAdapter(platformSfapJwtResolver, modifySfapResourceRequest);
-const composedNetworkAdapter$1 = {
-    shouldHandleRequest(resourceRequest) {
-        return resourceRequest.baseUri === SALESFORCE_API_BASE_URI_FLAG;
-    },
-    adapter: sfapNetworkAdapter,
-};
-
 const composedNetworkAdapter = buildComposableNetworkAdapter([
     composedNetworkAdapter$1,
     // The  aura network adapter must be the default.
@@ -3033,27 +3861,28 @@ function setupPredictivePrefetcher(luvio) {
     const inflightRequestLimit = applyPredictionRequestLimit.isOpen({ fallback: false })
         ? HARDCODED_REQUEST_LIMIT
         : 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 })) {
@@ -3184,7 +4013,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 +4030,15 @@ function initializeOneStore() {
         buildDefaultTypeRegistryService(),
         buildAuraNetworkService(),
         buildInMemoryCacheInclusionPolicyService(),
+        buildAuraNetworkCommandBaseClassService(),
+        buildFetchNetworkCommandBaseClassService(),
+        buildNetworkCommandBaseClassService(),
+        buildStreamingCommandBaseClassService(),
+        buildSSECommandBaseClassService(),
+        instrumentationServiceDescriptor,
+        buildInstrumentCommandServiceDescriptor({
+            instrumentation: instrumentationServiceDescriptor.service,
+        }),
     ];
     serviceBroker.publish(services);
 }
@@ -3221,4 +4067,4 @@ function ldsEngineCreator() {
 }
 
 export { buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore };
-// version: 1.301.0-ecd340c2e1
+// version: 1.303.0-a698c7cc67