@salesforce/lds-runtime-aura 1.284.0 → 1.286.0

package/dist/ldsEngineCreator.js

@@ -16,6 +16,7 @@ import { HttpStatusCode, InMemoryStore as InMemoryStore$1, Environment, Luvio, I
 import ldsTrackedFieldsBehaviorGate from '@salesforce/gate/lds.useNewTrackedFieldBehavior';
 import usePredictiveLoading from '@salesforce/gate/lds.usePredictiveLoading';
 import { instrument, getRecordAvatarsAdapterFactory, getRecordAdapterFactory, coerceFieldIdArray, getRecordsAdapterFactory, getRecordActionsAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoAdapterFactory, getRelatedListsActionsAdapterFactory, getRelatedListInfoBatchAdapterFactory, getRelatedListRecordsBatchAdapterFactory, getRelatedListRecordsAdapterFactory, configuration, InMemoryRecordRepresentationQueryEvaluator, UiApiNamespace, RecordRepresentationRepresentationType, registerPrefetcher } from 'force/ldsAdaptersUiapi';
+import { withRegistration as withRegistration$1 } from 'force/luvioRegistry';
 import oneStoreEnabled from '@salesforce/gate/lds.oneStoreEnabled.ltng';
 import { executeGlobalControllerRawResponse } from 'aura';
 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';
@@ -23,9 +24,10 @@ import { REFRESH_ADAPTER_EVENT, ADAPTER_UNFULFILLED_ERROR, instrument as instrum
 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 as withRegistration$1, register, setDefaultLuvio } from 'force/ldsEngine';
+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.,
@@ -33,61 +35,6 @@ import { buildJwtNetworkAdapter } from 'force/ldsNetworkFetchWithJwt';
  * For full license text, see the LICENSE.txt file
  */
 
-const { hasOwnProperty } = Object.prototype;
-
-function resolvedPromiseLike(result) {
-    // Don't nest anything promise like
-    if (isPromiseLike(result)) {
-        return result.then((nextResult) => nextResult);
-    }
-    return {
-        then: (onFulfilled, _onRejected) => {
-            if (onFulfilled) {
-                try {
-                    return resolvedPromiseLike(onFulfilled(result));
-                }
-                catch (e) {
-                    return rejectedPromiseLike(e);
-                }
-            }
-            // assume TResult1 == Result and just pass result down the chain
-            return resolvedPromiseLike(result);
-        },
-    };
-}
-/**
- * Returns a PromiseLike object that rejects with the specified reason.
- *
- * @param reason rejection value
- * @returns PromiseLike that rejects with reason
- */
-function rejectedPromiseLike(reason) {
-    if (isPromiseLike(reason)) {
-        return reason.then((nextResult) => nextResult);
-    }
-    return {
-        then: (_onFulfilled, onRejected) => {
-            if (onRejected) {
-                try {
-                    return resolvedPromiseLike(onRejected(reason));
-                }
-                catch (e) {
-                    return rejectedPromiseLike(e);
-                }
-            }
-            // assume TResult2 == Result and just pass rejection down the chain
-            return rejectedPromiseLike(reason);
-        },
-    };
-}
-function isPromiseLike(value) {
-    return (value instanceof Promise ||
-        (typeof value === 'object' &&
-            value !== null &&
-            hasOwnProperty.call(value, 'then') &&
-            typeof value.then === 'function'));
-}
-
 /**
  * A collection of keys, in no particular order.
  */
@@ -234,6 +181,412 @@ function buildInMemoryMetadataRepositoryService() {
     };
 }
 
+/**
+ * A RecordableStore wraps another Store and is used to record which keys in the
+ * other Store are read/written.
+ */
+class RecordableStore {
+    constructor(baseStore) {
+        this.baseStore = baseStore;
+        this.keysRead = new KeySetImpl();
+        this.missingKeysRead = new KeySetImpl();
+        this.keysUpdated = new KeySetImpl();
+    }
+    delete(key, options) {
+        this.keysUpdated.add(key);
+        this.baseStore.delete(key, options);
+    }
+    get(key, options) {
+        this.keysRead.add(key);
+        const value = this.baseStore.get(key, options);
+        if (value === undefined) {
+            this.missingKeysRead.add(key);
+        }
+        return value;
+    }
+    set(key, value, options) {
+        this.keysUpdated.add(key);
+        this.baseStore.set(key, value, options);
+    }
+    length() {
+        return this.baseStore.length();
+    }
+    keys() {
+        return this.baseStore.keys();
+    }
+    toKeySet(keys) {
+        return this.baseStore.toKeySet(keys);
+    }
+}
+
+/**
+ * A TTLFilteredStore wraps another Store and filters data from that Store
+ * to entries whose metadata indicates that it has not yet expired.
+ */
+class TTLFilteredStore {
+    constructor(baseStore, metadataRepository, now = Date.now()) {
+        this.baseStore = baseStore;
+        this.metadataRepository = metadataRepository;
+        this.now = now;
+    }
+    delete(key, options) {
+        this.baseStore.delete(key, options);
+    }
+    get(key, options) {
+        const metadata = this.metadataRepository.get(key);
+        if (metadata && metadata.expirationTime <= this.now) {
+            return undefined;
+        }
+        return this.baseStore.get(key, options);
+    }
+    set(key, value, options) {
+        this.baseStore.set(key, value, options);
+    }
+    length() {
+        return this.keys().length;
+    }
+    keys() {
+        return new KeySetImpl(this.baseStore
+            .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
+ */
+
+
+/**
+ * Utility function to generate a strongly-typed, empty set of Services. Aside from
+ * having the correct type, the returned set behaves as {} except it will throw an
+ * exception if an attempt is made to get a Service that has not been set.
+ *
+ * @typeParam Services the set of Services that will be stored in the set, typically
+ *     expressed as an intersection of Service types, e.g. FooService & BarService
+ * @returns empty set of Services
+ */
+function emptyServices() {
+    return new Proxy({}, {
+        get(services, serviceName, receiver) {
+            if (!(serviceName in services)) {
+                throw new Error(`service ${serviceName.toString()} not found`);
+            }
+            return Reflect.get(services, serviceName, receiver);
+        },
+    });
+}
+/**
+ * Indicates if a given instance of a service satisfies a request. Note that this function
+ * assumes the version numbers are valid strings.
+ *
+ * @param provided ServiceVersion of the service instance to be provided
+ * @param requested ServiceVersion requested
+ * @returns true if the service instance to be provided satisfies the request
+ */
+function satisfies(provided, requested) {
+    const providedN = provided.split('.').map((s) => parseInt(s));
+    const requestedN = requested.split('.').map((s) => parseInt(s));
+    return providedN[0] === requestedN[0] && providedN[1] >= requestedN[1];
+}
+
+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'));
+}
+
+// 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';
+    }
+}
+function isDataNotFoundError(error) {
+    return error instanceof DataNotFoundError || error.name === 'DataNotFoundError';
+}
+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;
+}
+
+/**
+ * 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.
+ */
+class InMemoryCacheInclusionPolicy {
+    /**
+     * Reads data out of a single level in memory store.
+     */
+    read(options) {
+        const { l1, readFromL1 } = options;
+        // l1 is all we've got
+        const readResult = readFromL1(l1);
+        return resolvedPromiseLike(readResult);
+    }
+    /**
+     * Writes data to a single level in memory store.
+     */
+    write(options) {
+        const { l1, writeToL1 } = options;
+        writeToL1(l1);
+        return resolvedPromiseLike(undefined);
+    }
+}
+/**
+ * Constructs an in-memory-only CacheInclusionPolicy.
+ *
+ * @returns in-memory-only CacheInclusionPolicy
+ */
+function buildInMemoryCacheInclusionPolicyService() {
+    return {
+        cacheInclusionPolicy: new InMemoryCacheInclusionPolicy(),
+    };
+}
+
+/**
+ * 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;
+        this.validator = validator;
+        this.policyName = 'cache-then-network';
+    }
+    run(options) {
+        const { readFromCache: readFromCacheOriginal, readFromNetwork: readFromNetworkOriginal, writeToCache: writeToCacheOriginal, buildResult, } = options;
+        // filter what data readFromCache is allowed to access from the store
+        const now = Date.now();
+        let ttlStore = new TTLFilteredStore(this.services.store, this.services.metadataRepository, now);
+        const { readFromCache: readFromCacheDedupe, readFromNetwork: readFromNetworkDedupe, writeToCache: writeToCacheDedupe, } = this.services.requestDedupe.applyDedupe({
+            readFromCache: (services) => this.readWithValidation(() => readFromCacheOriginal(services)),
+            readFromNetwork: readFromNetworkOriginal,
+            writeToCache: (services, networkResult) => this.writeWithValidation(() => writeToCacheOriginal(networkResult, services)),
+        });
+        return readFromCacheDedupe({ ...this.services, store: ttlStore }).then((value) => {
+            if (isCacheHitOrError(value)) {
+                return value;
+            }
+            // result not found in cache, try network
+            return readFromNetworkDedupe()
+                .then((value) => {
+                return writeToCacheDedupe(this.services, value).then(() => value);
+            })
+                .then((value) => {
+                const builtResult = buildResult(value, this.services);
+                this.validator.validateBuildResult(builtResult);
+                return builtResult;
+            });
+        });
+    }
+    readWithValidation(readFromCache) {
+        const readResult = readFromCache();
+        this.validator.validateReadResult(readResult);
+        return readResult;
+    }
+    writeWithValidation(writeToCache) {
+        const writeResult = writeToCache();
+        this.validator.validateWriteResult(writeResult);
+        return writeResult;
+    }
+}
+function buildCacheThenNetworkPolicy(services, validator) {
+    return new CacheThenNetworkPolicy(services, validator);
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * Exported for testing purposes only
+ */
+class KeyBasedRequestDedupe {
+    constructor() {
+        // TODO [W-12965475]: This class is a first pass at network deduplication. No consuming Commands should
+        // directly try to leverage this, as it will be refactored/removed in the future.
+        // This map tracks the mapping of the key set a given network request response is expected to contain
+        // to that network request's outstanding promise. Entries are added to this map when a request has
+        // a set of expected keys, and a new network request promise is created.
+        this.outstandingNetworkRequests = new Map();
+        // This map tracks the mapping of the keys a given read is waiting for to a resolve function that notifies the read
+        // that the keys it needs may now be present in the cache. This resolve function can be called when any network
+        // response is ingested, and the ingested keys contain the keys the read needs. This map is added to when
+        // we believe that an outstanding request may contain the keys needed to satisfy a read.
+        this.outstandingReads = new Map();
+    }
+    applyDedupe({ readFromCache, readFromNetwork, writeToCache, }) {
+        const closureVariables = { expectedNetworkKeys: undefined };
+        return {
+            readFromCache: this.buildDedupedReadFromCache(readFromCache, closureVariables),
+            readFromNetwork: this.buildDedupedReadFromNetwork(readFromNetwork, closureVariables),
+            writeToCache: this.buildDedupedWriteToCache(writeToCache),
+        };
+    }
+    buildDedupedReadFromCache(readFromCache, closureVariables) {
+        const dedupedReadFromCache = (services) => {
+            const recordableStore = new RecordableStore(services.store);
+            return readFromCache({ ...services, store: recordableStore }).then((value) => {
+                const missingKeys = recordableStore.missingKeysRead;
+                // if cache result was final, or we got a cache miss even though
+                // we don't recognize anything as missing then we're done
+                if (isCacheHitOrError(value) || missingKeys.length === 0) {
+                    return value;
+                }
+                // if we end up making a network request, we expect that it will return
+                // everything that was initially missing
+                if (!closureVariables.expectedNetworkKeys) {
+                    closureVariables.expectedNetworkKeys = missingKeys;
+                }
+                // build a list of the Promises for all the outstanding network requests
+                // that are expected to return at least one of our missing keys
+                let unrequestedKeys = services.store.toKeySet(missingKeys.elements());
+                const matchingRequests = Array.from(this.outstandingNetworkRequests.entries()).reduce((matches, [outstandingRequestKeys, promise]) => {
+                    if (outstandingRequestKeys.overlaps(missingKeys)) {
+                        matches.push(promise);
+                        unrequestedKeys = unrequestedKeys.difference(outstandingRequestKeys);
+                    }
+                    return matches;
+                }, []);
+                // if outstanding requests are not expected to return all the keys we need,
+                // return the cache read result
+                if (unrequestedKeys.length > 0) {
+                    return value;
+                }
+                // Create a promise that can be resolved if any outstanding requests satisfy
+                // the missing keys
+                const otherResultMatchesPromise = new Promise((resolve) => {
+                    this.outstandingReads.set(closureVariables.expectedNetworkKeys, resolve);
+                });
+                // wait for one of the matching network requests to come back, then retry
+                return Promise.race([otherResultMatchesPromise, ...matchingRequests])
+                    .then(() => {
+                    this.outstandingReads.delete(closureVariables.expectedNetworkKeys);
+                    return dedupedReadFromCache(services);
+                })
+                    .catch(() => {
+                    this.outstandingReads.delete(closureVariables.expectedNetworkKeys);
+                    return dedupedReadFromCache(services);
+                });
+            });
+        };
+        return dedupedReadFromCache;
+    }
+    buildDedupedReadFromNetwork(readFromNetwork, closureVariables) {
+        return () => {
+            if (closureVariables.expectedNetworkKeys === undefined ||
+                closureVariables.expectedNetworkKeys.length === 0) {
+                return readFromNetwork();
+            }
+            const deleteOutstandingRequest = () => this.outstandingNetworkRequests.delete(closureVariables.expectedNetworkKeys);
+            const networkPromise = readFromNetwork().then((value) => {
+                deleteOutstandingRequest();
+                return value;
+            }, (reason) => {
+                deleteOutstandingRequest();
+                return new Promise((_resolve, rejects) => {
+                    rejects(reason);
+                });
+            });
+            this.outstandingNetworkRequests.set(closureVariables.expectedNetworkKeys, networkPromise);
+            return networkPromise;
+        };
+    }
+    buildDedupedWriteToCache(writeToCache) {
+        return (services, networkResult) => {
+            const recordableStore = new RecordableStore(services.store);
+            const result = writeToCache({ ...services, store: recordableStore }, networkResult);
+            return result.then(() => {
+                const updatedKeys = recordableStore.keysUpdated;
+                Array.from(this.outstandingReads.entries()).forEach(([outstandingReadKeys, resolve]) => {
+                    if (outstandingReadKeys.isSubsetOf(updatedKeys)) {
+                        resolve();
+                    }
+                });
+            });
+        };
+    }
+}
+function buildKeyBasedRequestDedupeService() {
+    return { requestDedupe: new KeyBasedRequestDedupe() };
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
 /**
  * A simple implementation of KeyKeySubscriptionService.
  */
@@ -272,6 +625,13 @@ function buildDefaultKeySubscriptionService() {
     };
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
 class DefaultTypeNotFoundError extends Error {
 }
 class DefaultTypeRegistry {
@@ -308,69 +668,9 @@ function buildDefaultTypeRegistryService() {
     };
 }
 
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-/**
- * Registrations that have already occurred.
- *
- * Note that Registrations are maintained as a list rather than a map to allow
- * the same id to be registered multiple times with potentially different
- * data.
- */
-const registrations = [];
-/**
- * Invokes callback for each Registration, both past & future. That is, callback
- * will be invoked exactly as many times as register() is called.
- *
- * Note that Registration ids are not guaranteed to be unique. The meaning of
- * multiple Registrations with the same id is determined by the caller(s) of
- * register().
- */
-function forEachRegistration(callback) {
-    registrations.forEach((r) => callback(r));
-}
-/**
- * Invokes callback when the specified id is registered.
- *
- * Note that callback may be invoked:
- *
- *    - multiple times if multiple calls to register() specify the id
- *    - never if the specified id is never registered
- */
-function withRegistration(id, callback) {
-    forEachRegistration((r) => {
-        if (r.id === id) {
-            callback(r);
-        }
-    });
-}
-
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-/**
- * Indicates if a given instance of a service satisfies a request. Note that this function
- * assumes the version numbers are valid strings.
- *
- * @param provided ServiceVersion of the service instance to be provided
- * @param requested ServiceVersion requested
- * @returns true if the service instance to be provided satisfies the request
- */
-function satisfies(provided, requested) {
-    const providedN = provided.split('.').map((s) => parseInt(s));
-    const requestedN = requested.split('.').map((s) => parseInt(s));
-    return providedN[0] === requestedN[0] && providedN[1] >= requestedN[1];
-}
-
 const PDL_EXECUTE_ASYNC_OPTIONS = {
     LOG_ERROR_ONLY: true,
+    ERROR_SCOPE: 'lds-predictive-loading',
 };
 
 class PredictivePrefetchPage {
@@ -998,7 +1298,7 @@ function setAuraInstrumentationHooks() {
         weakEtagZero: instrumentation.aggregateWeakETagEvents.bind(instrumentation),
         getRecordNotifyChangeNetworkResult: instrumentation.notifyChangeNetwork.bind(instrumentation),
     });
-    withRegistration$1('@salesforce/lds-adapters-uiapi', (reg) => setLdsAdaptersUiapiInstrumentation(reg));
+    withRegistration('@salesforce/lds-adapters-uiapi', (reg) => setLdsAdaptersUiapiInstrumentation(reg));
     instrument$1({
         logCrud: logCRUDLightningInteraction,
         networkResponse: incrementRequestResponseCount,
@@ -1032,7 +1332,7 @@ function setAuraInstrumentationHooks() {
             },
         });
     }
-    withRegistration$1('@salesforce/lds-network-adapter', (reg) => setLdsNetworkAdapterInstrumentation(reg));
+    withRegistration('@salesforce/lds-network-adapter', (reg) => setLdsNetworkAdapterInstrumentation(reg));
 }
 /**
  * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
@@ -2299,22 +2599,29 @@ function initializeLDS() {
 }
 // Initializes OneStore in LEX
 function initializeOneStore() {
-    // Build default set of services
-    const services = {
-        ...buildDefaultKeySubscriptionService(),
-        ...buildInMemoryMetadataRepositoryService(),
-        ...buildInMemoryStoreService(),
-        ...buildDefaultTypeRegistryService(),
-        ...buildAuraNetworkService(),
+    const validator = {
+        validateReadResult() { },
+        validateWriteResult() { },
+        validateBuildResult() { },
     };
+    const services = emptyServices();
+    // Build default set of services
+    Object.assign(services, buildDefaultKeySubscriptionService(), buildInMemoryMetadataRepositoryService(), buildInMemoryStoreService(), buildDefaultTypeRegistryService(), buildAuraNetworkService(), buildInMemoryCacheInclusionPolicyService(), {
+        cachePolicy: {
+            cachePolicies: [buildCacheThenNetworkPolicy(services, validator)],
+            defaultCachePolicyName: 'cache-then-network',
+        },
+    }, buildKeyBasedRequestDedupeService());
     const serviceVersions = {
         keySubscription: "1.0" /* KeySubscriptionServiceInfo.VERSION */,
         metadataRepository: "1.0" /* MetadataRepositoryServiceInfo.VERSION */,
         store: "1.0" /* StoreServiceInfo.VERSION */,
         typeRegistry: "1.0" /* TypeRegistryServiceInfo.VERSION */,
         auraNetwork: "1.0" /* AuraNetworkServiceInfo.VERSION */,
+        cacheInclusionPolicy: "1.0" /* CacheInclusionPolicyServiceInfo.VERSION */,
+        cachePolicy: "1.0" /* CachePolicyServiceInfo.VERSION */,
     };
-    withRegistration('commandModule', (registration) => {
+    withRegistration$1('commandModule', (registration) => {
         const matchingServices = {};
         if (Object.entries(registration.services).every(([service, version]) => service in services &&
             satisfies(serviceVersions[service], version) &&
@@ -2322,13 +2629,11 @@ function initializeOneStore() {
             registration.setServices(matchingServices);
         }
     });
-    withRegistration('commandModule-uiapi', (registration) => {
+    withRegistration$1('commandModule-uiapi', (registration) => {
         if (Object.entries(registration.services).every(([service, version]) => service in services &&
             satisfies(serviceVersions[service], version) &&
             (services[service]))) {
-            // To-do: Revise how the adapter references get resolved - most likely through importing.
-            // https://github.com/salesforce-experience-platform-emu/lds-lightning-platform/pull/4961/files#r1522283942
-            const { getObjectInfo, getObjectInfos } = registration.setServices(services);
+            registration.setServices(services);
             configuration.setGetObjectInfoAdapter(getObjectInfo);
             configuration.setGetObjectInfosAdapter(getObjectInfos);
         }
@@ -2351,4 +2656,4 @@ function ldsEngineCreator() {
 }
 
 export { buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore };
-// version: 1.284.0-a7e8dc51c
+// version: 1.286.0-09e7e5207

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

@@ -1,3 +1,4 @@
 export declare const PDL_EXECUTE_ASYNC_OPTIONS: {
     LOG_ERROR_ONLY: boolean;
+    ERROR_SCOPE: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.284.0",
+    "version": "1.286.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -35,25 +35,34 @@
     },
     "devDependencies": {
         "@luvio/registry": "^3.0.0",
-        "@luvio/runtime": "3.4.3",
-        "@salesforce/lds-adapters-uiapi": "^1.284.0",
-        "@salesforce/lds-ads-bridge": "^1.284.0",
-        "@salesforce/lds-aura-storage": "^1.284.0",
-        "@salesforce/lds-bindings": "^1.284.0",
-        "@salesforce/lds-instrumentation": "^1.284.0",
-        "@salesforce/lds-network-aura": "^1.284.0",
-        "@salesforce/lds-network-fetch-with-jwt": "^1.284.0"
+        "@luvio/runtime": "^3.5.0",
+        "@luvio/service-cache-inclusion-policy": "^1.0.0",
+        "@luvio/service-cache-policy": "^1.0.0",
+        "@luvio/service-dedupe": "^1.0.0",
+        "@luvio/service-network": "^1.0.0",
+        "@luvio/service-store": "^1.0.0",
+        "@luvio/service-subscription": "^1.0.0",
+        "@luvio/service-type-registry": "^1.0.0",
+        "@luvio/utils": "^3.6.0",
+        "@salesforce/lds-adapters-uiapi": "^1.286.0",
+        "@salesforce/lds-ads-bridge": "^1.286.0",
+        "@salesforce/lds-aura-storage": "^1.286.0",
+        "@salesforce/lds-bindings": "^1.286.0",
+        "@salesforce/lds-instrumentation": "^1.286.0",
+        "@salesforce/lds-network-aura": "^1.286.0",
+        "@salesforce/lds-network-fetch-with-jwt": "^1.286.0"
     },
     "dependencies": {
-        "@luvio/network-adapter-composable": "0.154.15"
+        "@luvio/network-adapter-composable": "0.154.16",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.286.0"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "90 kB",
-                "min": "37.5 kB",
-                "compressed": "17 kB"
+                "none": "101 kB",
+                "min": "42 kB",
+                "compressed": "18.5 kB"
             }
         }
     ],

package/dist/types/__mocks__/@luvio/runtime.d.ts

@@ -1,25 +0,0 @@
-export declare enum KeySubscriptionServiceInfo {
-    NAME = "keySubscription",
-    VERSION = "1.0"
-}
-export declare enum MetadataRepositoryServiceInfo {
-    NAME = "metadataRepository",
-    VERSION = "1.0"
-}
-export declare enum StoreServiceInfo {
-    NAME = "store",
-    VERSION = "1.0"
-}
-export declare enum TypeRegistryServiceInfo {
-    NAME = "typeRegistry",
-    VERSION = "1.0"
-}
-export declare enum AuraNetworkServiceInfo {
-    NAME = "auraNetwork",
-    VERSION = "1.0"
-}
-export declare function buildDefaultKeySubscriptionService(): void;
-export declare function buildInMemoryMetadataRepositoryService(): void;
-export declare function buildInMemoryStoreService(): void;
-export declare function buildDefaultTypeRegistryService(): void;
-export declare function buildAuraNetworkService(): void;