@salesforce/lds-runtime-aura 1.358.0 → 1.360.0

package/dist/ldsEngineCreator.js

@@ -518,65 +518,130 @@ class CacheControlCommand extends BaseCommand {
     constructor(services) {
         super();
         this.services = services;
+        this.keysUsed = new Set();
+        this.keysUpdated = undefined;
         this.operationType = 'query';
-        this.rebuildUnsubscribe = () => { };
-        this.refreshUnsubscribe = () => { };
         this.lastEmittedData = undefined;
-        this.subscribeToKeys = () => undefined;
-        this.unsubscribeFromKeys = () => undefined;
+        this.unsubscribeFromKeysImpl = () => undefined;
         this.subscriptions = [];
         this.instantiationTime = Date.now() / 1000; // in seconds
     }
     execute(overrides) {
+        this.keysUpdated = undefined;
         this.unsubscribeFromKeys();
-        this.subscribeToKeys = () => undefined;
         const mergedCacheControlConfig = mergeCacheControlConfigs(this.cacheControlStrategyConfig, overrides);
-        const resultPromise = this.services.cacheController.execute(mergedCacheControlConfig, (cache) => this.buildRequestRunner(cache), {
+        let returnData;
+        let returnError;
+        const requestRunner = {
+            readFromCache: (cache) => {
+                const resultPromise = this.buildResultWithSubscribe(cache);
+                return resultPromise.then((result) => {
+                    if (result.isErr()) {
+                        return err(result.error);
+                    }
+                    returnData = result;
+                    return ok(undefined);
+                });
+            },
+            requestFromNetwork: () => {
+                const that = this;
+                return (async function* () {
+                    const result = await that.requestFromNetwork();
+                    if (result.isErr()) {
+                        returnError = result;
+                    }
+                    yield result;
+                })();
+            },
+            writeToCache: (cache, networkResult) => {
+                return this.writeToCacheAndRecordKeys(cache, networkResult);
+            },
+        };
+        const resultPromise = this.services.cacheController.execute(mergedCacheControlConfig, requestRunner, {
             instrumentationAttributes: this.instrumentationAttributes,
         });
         return resultPromise.then((result) => {
-            if (this.subscriptions.length > 0) {
-                this.subscribeToKeys();
-            }
-            if (result.isOk() && this.lastEmittedData === undefined) {
-                this.lastEmittedData = result.value.data;
+            return this.publishUpdatedKeys().then(() => {
+                // First check if there was an error from the network
+                if (returnError) {
+                    return returnError;
+                }
+                // Then return other errors from read/write
+                if (result.isErr()) {
+                    return err(result.error);
+                }
+                if (this.subscriptions.length > 0) {
+                    this.subscribeToKeysUsed();
+                }
+                if (returnData === undefined) {
+                    return err(new Error('Cache miss after fetching from network'));
+                }
+                if (returnData.isOk() && this.lastEmittedData === undefined) {
+                    this.lastEmittedData = returnData.value.data;
+                }
+                return returnData;
+            });
+        });
+    }
+    publishUpdatedKeys() {
+        if (this.services.pubSub) {
+            if (this.keysUpdated !== undefined && this.keysUpdated.size > 0) {
+                return this.services.pubSub.publish({
+                    type: 'cacheUpdate',
+                    data: this.keysUpdated,
+                });
             }
-            return result;
+        }
+        return resolvedPromiseLike(undefined);
+    }
+    subscribeToKeysUsed() {
+        this.unsubscribeFromKeys();
+        const { pubSub } = this.services;
+        if (!pubSub) {
+            this.unsubscribeFromKeysImpl = () => undefined;
+            return;
+        }
+        const rebuildUnsubscribe = pubSub.subscribe({
+            type: 'cacheUpdate',
+            predicate: (event) => setOverlaps(event.data, this.keysUsed),
+            callback: () => this.rerun({ now: this.instantiationTime }).then(() => undefined),
+            keys: this.keysUsed,
+        });
+        const refreshUnsubscribe = pubSub.subscribe({
+            type: 'cacheInvalidation',
+            predicate: (event) => setOverlaps(event.data, this.keysUsed),
+            callback: () => this.rerun().then(() => undefined),
+            keys: this.keysUsed,
         });
+        this.unsubscribeFromKeysImpl = () => {
+            rebuildUnsubscribe();
+            refreshUnsubscribe();
+        };
+        return;
+    }
+    unsubscribeFromKeys() {
+        this.unsubscribeFromKeysImpl();
     }
     // TODO: This should likely be abstract in v2.  For v1, provide default comparison logic.
     equals(result1, result2) {
         return deepEquals$1(result1, result2);
     }
-    buildRequestRunner(cache) {
-        return {
-            readFromCache: () => this.buildResultWithSubscribe(cache),
-            requestFromNetwork: () => this.requestFromNetwork(),
-            writeToCache: (networkResult) => this.writeToCacheAndPublish(cache, networkResult),
-        };
-    }
     async afterRequestHooks(_options) { }
     refresh() {
         return this.rerun({ cacheControlConfig: { type: 'no-cache' } }).then((result) => {
             if (result.isErr()) {
-                return result;
+                return err(result.error);
             }
             return ok(undefined);
         });
     }
-    // TODO: This is added as a temporary measure for ensuring that cache write events are
-    // published to pubSub. A follow-up will be required to find the right home for this logic.
-    writeToCacheAndPublish(cache, networkResult) {
+    writeToCacheAndRecordKeys(cache, networkResult) {
         const recordableCache = cache.record();
-        const writeResult = this.writeToCache(recordableCache, networkResult);
-        this.instantiationTime = Date.now() / 1000;
-        if (this.services.pubSub) {
-            this.services.pubSub.publish({
-                type: 'cacheUpdate',
-                data: recordableCache.keysUpdated,
-            });
-        }
-        return writeResult;
+        return this.writeToCache(recordableCache, networkResult).then((result) => {
+            this.instantiationTime = Date.now() / 1000;
+            this.keysUpdated = recordableCache.keysUpdated;
+            return ok(result);
+        });
     }
     buildResultWithSubscribe(cache) {
         const recordableCache = cache.record();
@@ -587,15 +652,12 @@ class CacheControlCommand extends BaseCommand {
             }
             else {
                 const data = readResult.value;
-                if (data !== undefined) {
-                    this.subscribeToKeys = () => this.subscribeToKeySet(recordableCache.keysRead);
-                    return ok({
-                        data,
-                        subscribe: this.buildSubscribe(),
-                        refresh: () => this.refresh(),
-                    });
-                }
-                return ok(undefined);
+                this.keysUsed = recordableCache.keysRead;
+                return ok({
+                    data,
+                    subscribe: this.buildSubscribe(),
+                    refresh: () => this.refresh(),
+                });
             }
         });
     }
@@ -611,7 +673,7 @@ class CacheControlCommand extends BaseCommand {
     buildSubscribe() {
         return (consumerCallback) => {
             if (this.subscriptions.length === 0 && this.operationType === 'query') {
-                this.subscribeToKeys();
+                this.subscribeToKeysUsed();
             }
             this.subscriptions.push(consumerCallback);
             return () => {
@@ -635,27 +697,6 @@ class CacheControlCommand extends BaseCommand {
             return result;
         });
     }
-    subscribeToKeySet(keysRead) {
-        const { pubSub } = this.services;
-        if (!pubSub) {
-            return;
-        }
-        const createKeySubscriber = (type, callback) => pubSub.subscribe({
-            type,
-            predicate: (event) => setOverlaps(event.data, keysRead),
-            callback,
-        });
-        // Unsubscribe to be sure that this command didn't re-execute and re-subscribe in between the start of command execution and now
-        // it shouldn't be possible for this command to resubscribe between the beginning of execution and now
-        // ...but lets be defensive.
-        this.unsubscribeFromKeys();
-        const rebuildUnsubscribe = createKeySubscriber('cacheUpdate', () => this.rerun({ now: this.instantiationTime }).then(() => undefined));
-        const refreshUnsubscribe = createKeySubscriber('cacheInvalidation', () => this.rerun().then(() => undefined));
-        this.unsubscribeFromKeys = () => {
-            rebuildUnsubscribe();
-            refreshUnsubscribe();
-        };
-    }
     invokeConsumerCallbacks(data) {
         this.subscriptions.forEach((cb) => {
             try {
@@ -771,13 +812,19 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand {
     }
     readFromCache(cache) {
         var _a;
-        return resolvedPromiseLike(ok((_a = cache.get(this.buildKey())) === null || _a === void 0 ? void 0 : _a.value));
+        const data = (_a = cache.get(this.buildKey())) === null || _a === void 0 ? void 0 : _a.value;
+        if (data === undefined) {
+            return resolvedPromiseLike(err(new Error('Failed to find data in cache')));
+        }
+        return resolvedPromiseLike(ok(data));
     }
     writeToCache(cache, networkResult) {
         if (networkResult.isOk()) {
             cache.set(this.buildKey(), {
                 value: networkResult.value,
-                metadata: { cacheControl: this.buildCacheControlMetadata(networkResult.value) },
+                metadata: {
+                    cacheControl: this.buildCacheControlMetadata(networkResult.value),
+                },
             });
         }
         return resolvedPromiseLike(undefined);
@@ -1735,18 +1782,14 @@ function buildServiceDescriptor$4() {
 
 
 class CacheControlStrategy {
-    constructor(services, config, buildRequestRunner) {
+    constructor(services, config, requestRunner) {
         this.services = services;
         this.config = config;
-        const requestRunnerCache = this.services.cache.filter((_, entry) => {
+        this.requestRunner = requestRunner;
+        this.filteredCache = this.services.cache.filter((_, entry) => {
             const { cacheControl } = entry.metadata;
             return !this.expiredChecks.some((check) => check(cacheControl));
         });
-        this.requestRunner = buildRequestRunner(requestRunnerCache);
-    }
-    isCacheHit(cacheReadValue) {
-        const isCacheMiss = cacheReadValue.isErr() || cacheReadValue.value === undefined;
-        return !isCacheMiss;
     }
     get expiredChecks() {
         return [
@@ -1760,45 +1803,90 @@ class CacheControlStrategy {
     }
 }
 
+class NoCacheCacheControlStrategy extends CacheControlStrategy {
+    execute() {
+        // TODO - should be using wrapper here that suppresses no-store writes
+        const tempCache = this.filteredCache;
+        return new Promise(async (resolve, reject) => {
+            try {
+                let readResult = ok(undefined);
+                for await (const rfnResult of this.requestRunner.requestFromNetwork()) {
+                    if (rfnResult) {
+                        const result = await this.services.cacheInclusionPolicy.write({
+                            l1: tempCache,
+                            writeToL1: (l1) => this.requestRunner.writeToCache(l1, rfnResult),
+                        });
+                        if (result.isErr()) {
+                            return resolve(result);
+                        }
+                    }
+                    // give readFromCache another shot at the cache
+                    readResult = await this.services.cacheInclusionPolicy.read({
+                        l1: tempCache,
+                        readFromL1: (l1) => this.requestRunner.readFromCache(l1),
+                    });
+                    if (readResult.isOk()) {
+                        resolve(readResult);
+                    }
+                }
+                return resolve(readResult);
+            }
+            catch (error) {
+                return reject(error);
+            }
+        });
+    }
+}
+
 class MaxAgeCacheControlStrategy extends CacheControlStrategy {
     execute(options) {
         const startTime = this.services.instrumentation
             ? this.services.instrumentation.currentTimeMs()
             : 0;
-        return this.requestRunner.readFromCache().then((value) => {
-            if (this.isCacheHit(value)) {
-                this.collectCacheHitInstrumentation(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
-                return value;
-            }
-            return this.handleCacheMiss(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
-        });
-    }
-    handleCacheMiss(startTime, instrumentationAttributes) {
-        let error;
-        return this.requestRunner
-            .requestFromNetwork()
-            .then((value) => {
-            if (value.isErr()) {
-                error = value;
-                return resolvedPromiseLike(null);
-            }
-            return this.requestRunner.writeToCache(value);
-        })
-            .then(() => {
-            if (error) {
-                return resolvedPromiseLike(null);
-            }
-            return this.requestRunner.readFromCache();
+        return this.services.cacheInclusionPolicy
+            .read({
+            l1: this.filteredCache,
+            readFromL1: (l1) => this.requestRunner.readFromCache(l1),
         })
             .then((value) => {
-            if (value === null) {
-                return error;
-            }
-            if (!this.isCacheHit(value)) {
-                return err(new Error('Cache miss after fetching from network'));
+            // ignore error from initial cache read
+            if (value.isOk()) {
+                this.collectCacheHitInstrumentation(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
+                return ok(undefined);
             }
-            this.collectCacheMissInstrumentation(startTime, instrumentationAttributes);
-            return value;
+            this.collectCacheMissInstrumentation(startTime, options === null || options === void 0 ? void 0 : options.instrumentationAttributes);
+            // initial cache read failed, awaits are ok beyond this point since the data
+            // must come from network requests
+            const tempCache = this.filteredCache;
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let readResult = ok(undefined);
+                    for await (const rfnResult of this.requestRunner.requestFromNetwork()) {
+                        // async generator has a value to ingest
+                        if (rfnResult) {
+                            const result = await this.services.cacheInclusionPolicy.write({
+                                l1: tempCache,
+                                writeToL1: (l1) => this.requestRunner.writeToCache(l1, rfnResult),
+                            });
+                            if (result.isErr()) {
+                                return resolve(err(result.error));
+                            }
+                        }
+                        // give readFromCache another shot at the cache
+                        readResult = await this.services.cacheInclusionPolicy.read({
+                            l1: tempCache,
+                            readFromL1: (l1) => this.requestRunner.readFromCache(l1),
+                        });
+                        if (readResult.isOk()) {
+                            resolve(ok(undefined));
+                        }
+                    }
+                    return resolve(readResult);
+                }
+                catch (e) {
+                    return reject(e);
+                }
+            });
         });
     }
     collectCacheHitInstrumentation(startTime, instrumentationAttributes) {
@@ -1834,118 +1922,6 @@ class MaxAgeCacheControlStrategy extends CacheControlStrategy {
     }
 }
 
-class NoCacheCacheControlStrategy extends CacheControlStrategy {
-    execute() {
-        return this.requestRunner.requestFromNetwork().then((networkResult) => {
-            if (networkResult.isErr()) {
-                return networkResult;
-            }
-            // Attempt to write to the cache
-            return this.requestRunner
-                .writeToCache(networkResult)
-                .then(() => this.requestRunner.readFromCache())
-                .then((cachedResult) => {
-                if (!this.isCacheHit(cachedResult)) {
-                    return err(new Error('Cache miss after saving network result'));
-                }
-                return cachedResult;
-            });
-        });
-    }
-}
-
-const isAndQuery = (query) => '$and' in query;
-const isOrQuery = (query) => '$or' in query;
-const isNotQuery = (query) => '$not' in query;
-const matchesMetadata = (metadataQuery, cacheControl) => {
-    var _a;
-    if ('cacheControlType' in metadataQuery &&
-        cacheControl.type !== metadataQuery.cacheControlType.$eq) {
-        return false;
-    }
-    if ('maxAge' in metadataQuery && cacheControl.type === 'max-age') {
-        const maxAge = (_a = cacheControl.maxAge) !== null && _a !== void 0 ? _a : 0;
-        if ((metadataQuery.maxAge.$gte !== undefined && maxAge < metadataQuery.maxAge.$gte) ||
-            (metadataQuery.maxAge.$lte !== undefined && maxAge > metadataQuery.maxAge.$lte)) {
-            return false;
-        }
-    }
-    return true;
-};
-function queryToPredicate(query) {
-    return (key, entry) => {
-        if (!query)
-            return false;
-        if (isAndQuery(query))
-            return query.$and.every((subQuery) => queryToPredicate(subQuery)(key, entry));
-        if (isOrQuery(query))
-            return query.$or.some((subQuery) => queryToPredicate(subQuery)(key, entry));
-        if (isNotQuery(query))
-            return !queryToPredicate(query.$not)(key, entry);
-        if ('key' in query)
-            return matchesKey(query.key, key);
-        if ('metadata' in query)
-            return matchesMetadata(query.metadata, entry.metadata.cacheControl);
-        if ('value' in query)
-            return false; // TODO: Not implemented
-        throw new Error('Unknown Query Operation');
-    };
-}
-function matchesKey(keyQuery, key) {
-    if ('$regex' in keyQuery) {
-        return keyQuery.$regex.test(key);
-    }
-    return false;
-}
-
-/**
- * Processes a cache update operation and determines the appropriate modification.
- *
- * This function analyzes the provided `update` and the `existing` cache entry
- * to determine the necessary update type. It returns one of three possible outcomes:
- *
- * - `{ type: 'entry', entry }`: A full cache entry update, including both value and metadata.
- * - `{ type: 'metadata', metadata }`: A metadata-only update, leaving the value unchanged.
- * - `{ type: 'no-op' }`: No changes are needed, and the cache should remain as is.
- *
- * @param update - The cache update operation to apply.
- * @param existing - The existing cache entry being modified.
- * @returns An object indicating the type of update:
- *   - A full cache entry update (`type: 'entry'`)
- *   - A metadata-only update (`type: 'metadata'`)
- *   - A no-op (`type: 'no-op'`) if no changes are required.
- */
-function buildUpdate(update, existing) {
-    switch (update.type) {
-        case 'invalidate':
-            const updatedCacheControl = buildInvalidatedCacheControl(existing.metadata.cacheControl);
-            return updatedCacheControl !== undefined
-                ? { type: 'metadata', metadata: updatedCacheControl }
-                : { type: 'no-op' };
-        default:
-            throw new Error(`Invalid update operation: ${update.type}`);
-    }
-}
-/**
- * Builds an updated CacheControlMetadata object that invalidates the cache entry.
- *
- * @param existingCacheControl - The current CacheControlMetadata.
- * @returns A new CacheControlMetadata object with `maxAge` set to `0`, or undefined if no changes are needed.
- */
-function buildInvalidatedCacheControl(existingCacheControl) {
-    switch (existingCacheControl.type) {
-        case 'max-age':
-        case 'stale-while-revalidate':
-            if (existingCacheControl.maxAge !== 0) {
-                return {
-                    ...existingCacheControl,
-                    maxAge: 0,
-                };
-            }
-    }
-    return undefined; // No-op: no changes
-}
-
 /**
  * A class that allows the execution of requested cache control strategies,
  * while also enforcing the canonical cache control metadata.
@@ -1954,16 +1930,16 @@ class CacheController {
     constructor(services) {
         this.services = services;
     }
-    execute(config, buildRequestRunner, options) {
-        const strategy = this.getCacheControlStrategy(config, buildRequestRunner);
+    execute(config, requestRunner, options) {
+        const strategy = this.getCacheControlStrategy(config, requestRunner);
         return strategy.execute(options);
     }
-    getCacheControlStrategy(config, buildRequestRunner) {
+    getCacheControlStrategy(config, requestRunner) {
         if (config.type === 'max-age') {
-            return new MaxAgeCacheControlStrategy(this.services, config, buildRequestRunner);
+            return new MaxAgeCacheControlStrategy(this.services, config, requestRunner);
         }
         else if (config.type === 'no-cache') {
-            return new NoCacheCacheControlStrategy(this.services, config, buildRequestRunner);
+            return new NoCacheCacheControlStrategy(this.services, config, requestRunner);
         }
         throw new Error(`Unknown cache control strategy ${config.type}`);
     }
@@ -1972,39 +1948,22 @@ class CacheController {
      * Returns an async generator that yields `[key, entry]`.
      */
     async *find(query) {
-        const cache = this.services.cache;
-        const predicate = queryToPredicate(query);
-        const filteredEntries = cache.filter(predicate).entries();
-        for (const entry of filteredEntries) {
-            yield entry;
-        }
+        yield* this.services.cacheInclusionPolicy.find(query);
     }
     /**
      * Finds and modifies cache entries that match the given query.
      * Extends `find(query)` and returns an async generator of modified keys.
      */
     async *findAndModify(query, cacheUpdate) {
-        for await (const [key, value] of this.find(query)) {
-            const update = buildUpdate(cacheUpdate, value);
-            switch (update.type) {
-                case 'entry':
-                    this.services.cache.set(key, update.entry);
-                    yield key;
-                    break;
-                case 'metadata':
-                    this.services.cache.setMetadata(key, update.metadata);
-                    yield key;
-                    break;
-            }
-        }
+        yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
     }
 }
 
-function buildServiceDescriptor$3(cache) {
+function buildServiceDescriptor$3(cache, cacheInclusionPolicy) {
     return {
         type: 'cacheController',
         version: '1.0',
-        service: new CacheController({ cache }),
+        service: new CacheController({ cache, cacheInclusionPolicy }),
     };
 }
 
@@ -2032,14 +1991,33 @@ class DefaultPubSubService {
         }
         eventTypeSubscriptions.push(subscription);
         return () => {
-            this.subscriptions.set(subscription.type, eventTypeSubscriptions.filter((value) => value !== subscription));
+            this.subscriptions.set(subscription.type, this.subscriptions.get(subscription.type).filter((value) => value !== subscription));
         };
     }
     publish(event) {
+        const promises = [];
+        const subscriptions = this.getSubscriptions(event);
+        subscriptions.forEach((subscription) => {
+            // need to check that the subscription hasn't been unsubscribed during one of the callbacks
+            if (!this.getSubscriptions(event).includes(subscription)) {
+                return;
+            }
+            // Ensure callback maintains its context
+            const returnVal = subscription.callback.call(subscription, event);
+            if (isPromiseLike(returnVal)) {
+                promises.push(returnVal);
+            }
+        });
+        if (promises.length > 0) {
+            return Promise.all(promises).then(() => undefined);
+        }
+        return resolvedPromiseLike(undefined);
+    }
+    getSubscriptions(event) {
         const eventTypeSubscriptions = this.subscriptions.get(event.type);
         const wildcardSubscriptions = this.subscriptions.get(EventTypeWildcard);
         if (eventTypeSubscriptions === undefined && wildcardSubscriptions === undefined) {
-            return resolvedPromiseLike(undefined);
+            return [];
         }
         let matchingSubscriptions = [];
         if (eventTypeSubscriptions !== undefined) {
@@ -2051,17 +2029,7 @@ class DefaultPubSubService {
             });
         }
         matchingSubscriptions = [...matchingSubscriptions, ...(wildcardSubscriptions || [])];
-        const promises = [];
-        matchingSubscriptions.forEach((subscription) => {
-            const returnVal = subscription.callback(event);
-            if (isPromiseLike(returnVal)) {
-                promises.push(returnVal);
-            }
-        });
-        if (promises.length > 0) {
-            return Promise.all(promises).then(() => undefined);
-        }
-        return resolvedPromiseLike(undefined);
+        return matchingSubscriptions;
     }
 }
 /**
@@ -2704,7 +2672,7 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.156.7-d2b9c7ef
+// engine version: 0.157.4-1c316582
 
 const { keys: keys$1 } = Object;
 
@@ -5689,7 +5657,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.358.0-abc73971a1
+// version: 1.360.0-3cf173d4f8
 
 const forceRecordTransactionsDisabled = getEnvironmentSetting(EnvironmentSettings.ForceRecordTransactionsDisabled);
 //TODO: Some duplication here that can be most likely moved to a util class
@@ -6100,6 +6068,190 @@ class PredictionsReadyManager {
     }
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+/**
+ * CacheInclusionPolicy is an interface for accessing the cache
+ * and synchronizing the cache data with another external cache.
+ *
+ * https://en.wikipedia.org/wiki/Cache_inclusion_policy
+ */
+class CacheInclusionPolicyService {
+}
+
+const isAndQuery = (query) => '$and' in query;
+const isOrQuery = (query) => '$or' in query;
+const isNotQuery = (query) => '$not' in query;
+const matchesMetadata = (metadataQuery, cacheControl) => {
+    var _a;
+    if ('cacheControlType' in metadataQuery &&
+        cacheControl.type !== metadataQuery.cacheControlType.$eq) {
+        return false;
+    }
+    if ('maxAge' in metadataQuery && cacheControl.type === 'max-age') {
+        const maxAge = (_a = cacheControl.maxAge) !== null && _a !== void 0 ? _a : 0;
+        if ((metadataQuery.maxAge.$gte !== undefined && maxAge < metadataQuery.maxAge.$gte) ||
+            (metadataQuery.maxAge.$lte !== undefined && maxAge > metadataQuery.maxAge.$lte)) {
+            return false;
+        }
+    }
+    return true;
+};
+function queryToPredicate(query) {
+    return (key, entry) => {
+        if (!query)
+            return false;
+        if (isAndQuery(query))
+            return query.$and.every((subQuery) => queryToPredicate(subQuery)(key, entry));
+        if (isOrQuery(query))
+            return query.$or.some((subQuery) => queryToPredicate(subQuery)(key, entry));
+        if (isNotQuery(query))
+            return !queryToPredicate(query.$not)(key, entry);
+        if ('key' in query)
+            return matchesKey(query.key, key);
+        if ('metadata' in query)
+            return matchesMetadata(query.metadata, entry.metadata.cacheControl);
+        if ('value' in query)
+            return false; // TODO: Not implemented
+        throw new Error('Unknown Query Operation');
+    };
+}
+function matchesKey(keyQuery, key) {
+    if ('$regex' in keyQuery) {
+        return keyQuery.$regex.test(key);
+    }
+    return false;
+}
+
+/**
+ * Processes a cache update operation and determines the appropriate modification.
+ *
+ * This function analyzes the provided `update` and the `existing` cache entry
+ * to determine the necessary update type. It returns one of three possible outcomes:
+ *
+ * - `{ type: 'entry', entry }`: A full cache entry update, including both value and metadata.
+ * - `{ type: 'metadata', metadata }`: A metadata-only update, leaving the value unchanged.
+ * - `{ type: 'no-op' }`: No changes are needed, and the cache should remain as is.
+ *
+ * @param update - The cache update operation to apply.
+ * @param existing - The existing cache entry being modified.
+ * @returns An object indicating the type of update:
+ *   - A full cache entry update (`type: 'entry'`)
+ *   - A metadata-only update (`type: 'metadata'`)
+ *   - A no-op (`type: 'no-op'`) if no changes are required.
+ */
+function buildUpdate(update, existing) {
+    switch (update.type) {
+        case 'invalidate':
+            const updatedCacheControl = buildInvalidatedCacheControl(existing.metadata.cacheControl);
+            return updatedCacheControl !== undefined
+                ? { type: 'metadata', metadata: updatedCacheControl }
+                : { type: 'no-op' };
+        default:
+            throw new Error(`Invalid update operation: ${update.type}`);
+    }
+}
+/**
+ * Builds an updated CacheControlMetadata object that invalidates the cache entry.
+ *
+ * @param existingCacheControl - The current CacheControlMetadata.
+ * @returns A new CacheControlMetadata object with `maxAge` set to `0`, or undefined if no changes are needed.
+ */
+function buildInvalidatedCacheControl(existingCacheControl) {
+    switch (existingCacheControl.type) {
+        case 'max-age':
+        case 'stale-while-revalidate':
+            if (existingCacheControl.maxAge !== 0) {
+                return {
+                    ...existingCacheControl,
+                    maxAge: 0,
+                };
+            }
+    }
+    return undefined; // No-op: no changes
+}
+
+/**
+ * Implementation of CacheInclusionPolicy that uses a single level, in memory,
+ * synchronous L1 cache.
+ */
+class InMemoryCacheInclusionPolicy extends CacheInclusionPolicyService {
+    constructor(services) {
+        super();
+        this.services = services;
+    }
+    /**
+     * Reads data out of a single level in memory store.
+     */
+    read(options) {
+        const { l1, readFromL1 } = options;
+        // l1 is all we've got
+        return readFromL1(l1);
+    }
+    /**
+     * Writes data to a single level in memory store.
+     */
+    write(options) {
+        const { l1, writeToL1 } = options;
+        return writeToL1(l1);
+    }
+    /**
+     * Finds cache entries that match the given query.
+     * Returns an async generator that yields `[key, entry]`.
+     */
+    async *find(query) {
+        const cache = this.services.cache;
+        const predicate = queryToPredicate(query);
+        const filteredEntries = cache.filter(predicate).entries();
+        for (const entry of filteredEntries) {
+            yield entry;
+        }
+    }
+    /**
+     * Finds and modifies cache entries that match the given query.
+     * Extends `find(query)` and returns an async generator of modified keys.
+     */
+    async *findAndModify(query, cacheUpdate) {
+        const cache = this.services.cache;
+        for await (const [key, value] of this.find(query)) {
+            const update = buildUpdate(cacheUpdate, value);
+            switch (update.type) {
+                case 'entry':
+                    this.write({
+                        l1: cache,
+                        writeToL1: (l1) => resolvedPromiseLike(ok(l1.set(key, update.entry))),
+                    });
+                    yield key;
+                    break;
+                case 'metadata':
+                    this.write({
+                        l1: cache,
+                        writeToL1: (l1) => resolvedPromiseLike(ok(l1.setMetadata(key, update.metadata))),
+                    });
+                    yield key;
+                    break;
+            }
+        }
+    }
+}
+/**
+ * Constructs an in-memory-only CacheInclusionPolicy.
+ *
+ * @returns in-memory-only CacheInclusionPolicy
+ */
+function buildInMemoryCacheInclusionPolicyService(cache) {
+    return {
+        service: new InMemoryCacheInclusionPolicy({ cache }),
+        type: 'cacheInclusionPolicy',
+        version: '1.0',
+    };
+}
+
 // This code *should* be in lds-network-adapter, but when combined with the Aura
 // component test workaround in lds-default-luvio it creates a circular dependecy
 // between lds-default-luvio and lds-network-adapter. We do the register on behalf
@@ -6342,6 +6494,7 @@ function initializeOneStore() {
     const loggerService = new ConsoleLogger$1('ERROR');
     const cacheServiceDescriptor = buildServiceDescriptor$4();
     const instrumentationServiceDescriptor = buildServiceDescriptor$5(loggerService);
+    const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
     const services = [
         instrumentationServiceDescriptor,
         buildUnauthorizedFetchServiceDescriptor(),
@@ -6349,7 +6502,7 @@ function initializeOneStore() {
         buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
         buildServiceDescriptor$6(instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$3(cacheServiceDescriptor.service),
+        buildServiceDescriptor$3(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service),
         buildServiceDescriptor$d(),
         buildServiceDescriptor$1(),
         buildServiceDescriptor$9(),
@@ -6382,4 +6535,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.358.0-d83368bac0
+// version: 1.360.0-580249acee

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.358.0",
+    "version": "1.360.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -34,48 +34,49 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-aura"
     },
     "devDependencies": {
-        "@luvio/service-provisioner": " 5.39.0",
-        "@luvio/tools-core": " 5.39.0",
-        "@salesforce/lds-adapters-apex": "^1.358.0",
-        "@salesforce/lds-adapters-uiapi": "^1.358.0",
+        "@luvio/service-provisioner": "5.40.3",
+        "@luvio/tools-core": "5.40.3",
+        "@salesforce/lds-adapters-apex": "^1.360.0",
+        "@salesforce/lds-adapters-uiapi": "^1.360.0",
         "@salesforce/lds-adapters-uiapi-lex": "^1.302.0",
-        "@salesforce/lds-ads-bridge": "^1.358.0",
-        "@salesforce/lds-aura-storage": "^1.358.0",
-        "@salesforce/lds-bindings": "^1.358.0",
-        "@salesforce/lds-instrumentation": "^1.358.0",
-        "@salesforce/lds-network-aura": "^1.358.0",
-        "@salesforce/lds-network-fetch": "^1.358.0",
+        "@salesforce/lds-ads-bridge": "^1.360.0",
+        "@salesforce/lds-aura-storage": "^1.360.0",
+        "@salesforce/lds-bindings": "^1.360.0",
+        "@salesforce/lds-instrumentation": "^1.360.0",
+        "@salesforce/lds-network-aura": "^1.360.0",
+        "@salesforce/lds-network-fetch": "^1.360.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
-        "@luvio/command-aura-network": " 5.39.0",
-        "@luvio/command-aura-normalized-cache-control": " 5.39.0",
-        "@luvio/command-aura-resource-cache-control": " 5.39.0",
-        "@luvio/command-fetch-network": " 5.39.0",
-        "@luvio/command-http-normalized-cache-control": " 5.39.0",
-        "@luvio/command-ndjson": " 5.39.0",
-        "@luvio/command-network": " 5.39.0",
-        "@luvio/command-sse": " 5.39.0",
-        "@luvio/command-streaming": " 5.39.0",
-        "@luvio/network-adapter-composable": "0.156.7",
-        "@luvio/network-adapter-fetch": "0.156.7",
-        "@luvio/service-aura-network": " 5.39.0",
-        "@luvio/service-cache": " 5.39.0",
-        "@luvio/service-cache-control": " 5.39.0",
-        "@luvio/service-fetch-network": " 5.39.0",
-        "@luvio/service-instrument-command": " 5.39.0",
-        "@luvio/service-pubsub": " 5.39.0",
-        "@luvio/service-store": " 5.39.0",
-        "@luvio/utils": " 5.39.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.358.0"
+        "@luvio/command-aura-network": "5.40.3",
+        "@luvio/command-aura-normalized-cache-control": "5.40.3",
+        "@luvio/command-aura-resource-cache-control": "5.40.3",
+        "@luvio/command-fetch-network": "5.40.3",
+        "@luvio/command-http-normalized-cache-control": "5.40.3",
+        "@luvio/command-ndjson": "5.40.3",
+        "@luvio/command-network": "5.40.3",
+        "@luvio/command-sse": "5.40.3",
+        "@luvio/command-streaming": "5.40.3",
+        "@luvio/network-adapter-composable": "0.157.4",
+        "@luvio/network-adapter-fetch": "0.157.4",
+        "@luvio/service-aura-network": "5.40.3",
+        "@luvio/service-cache": "5.40.3",
+        "@luvio/service-cache-control": "5.40.3",
+        "@luvio/service-cache-inclusion-policy": "5.40.3",
+        "@luvio/service-fetch-network": "5.40.3",
+        "@luvio/service-instrument-command": "5.40.3",
+        "@luvio/service-pubsub": "5.40.3",
+        "@luvio/service-store": "5.40.3",
+        "@luvio/utils": "5.40.3",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.360.0"
     },
     "luvioBundlesize": [
         {
             "path": "./dist/ldsEngineCreator.js",
             "maxSize": {
-                "none": "238 kB",
-                "min": "98 kB",
-                "compressed": "41 kB"
+                "none": "245 kB",
+                "min": "100 kB",
+                "compressed": "45 kB"
             }
         }
     ],