@salesforce/lds-runtime-aura 1.399.0 → 1.401.0

package/dist/ldsEngineCreator.js

@@ -51,7 +51,7 @@ import useHttpUiapiOneRuntime from '@salesforce/gate/lds.useHttpUiapiOneRuntime'
  */
 const { create: create$1, freeze, keys: keys$2, entries: entries$1 } = Object;
 const { isArray: isArray$3 } = Array;
-const { stringify: stringify$2, parse: parse$1 } = JSON;
+const { stringify: stringify$3, parse: parse$2 } = JSON;
 const LogLevelMap$1 = {
   TRACE: 4,
   DEBUG: 3,
@@ -179,7 +179,7 @@ function stableJSONStringify$2(node) {
     return isFinite(node) ? "" + node : "null";
   }
   if (typeof node !== "object") {
-    return stringify$2(node);
+    return stringify$3(node);
   }
   let i;
   let out;
@@ -207,7 +207,7 @@ function stableJSONStringify$2(node) {
     if (out) {
       out += ",";
     }
-    out += stringify$2(key) + ":" + value;
+    out += stringify$3(key) + ":" + value;
   }
   return "{" + out + "}";
 }
@@ -341,7 +341,7 @@ let NetworkCommand$1 = class NetworkCommand extends BaseCommand {
   async afterRequestHooks(_options) {
   }
 };
-function buildServiceDescriptor$j() {
+function buildServiceDescriptor$k() {
   return {
     type: "networkCommandBaseClass",
     version: "1.0",
@@ -443,7 +443,7 @@ class AuraNetworkCommand extends NetworkCommand$1 {
     return resolvedPromiseLike$3(err$1(toError("Aura/Fetch network services not found")));
   }
 }
-function buildServiceDescriptor$i() {
+function buildServiceDescriptor$j() {
   return {
     type: "auraNetworkCommandBaseClass",
     version: "1.0",
@@ -1131,7 +1131,7 @@ class AuraResourceCacheControlCommand extends AuraCacheControlCommand$1 {
     return `{"endpoint":${this.endpoint},"params":${stableJSONStringify$2(this.auraParams)}}`;
   }
 }
-function buildServiceDescriptor$h() {
+function buildServiceDescriptor$i() {
   return {
     type: "auraResourceCacheControlCommand",
     version: "1.0",
@@ -1255,7 +1255,7 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
     const data = this.buildResultType().query(cache, this.buildQuery());
     if (data.isErr()) {
       return resolvedPromiseLike$3(
-        err$1(new Error(`Failed to build data from type: ${stringify$2(data.error)}`))
+        err$1(new Error(`Failed to build data from type: ${stringify$3(data.error)}`))
       );
     }
     return resolvedPromiseLike$3(ok$2(data.value));
@@ -1270,7 +1270,7 @@ class AuraNormalizedCacheControlCommand extends AuraCacheControlCommand {
     return resolvedPromiseLike$3(void 0);
   }
 }
-function buildServiceDescriptor$g() {
+function buildServiceDescriptor$h() {
   return {
     type: "auraNormalizedCacheControlCommand",
     version: "1.0",
@@ -1344,7 +1344,7 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
     const data = this.buildResultType().query(cache, this.buildQuery());
     if (data.isErr()) {
       return resolvedPromiseLike$3(
-        err$1(new Error(`Failed to build data from type: ${stringify$2(data.error)}`))
+        err$1(new Error(`Failed to build data from type: ${stringify$3(data.error)}`))
       );
     }
     return resolvedPromiseLike$3(ok$2(data.value));
@@ -1359,7 +1359,7 @@ class HttpNormalizedCacheControlCommand extends HttpCacheControlCommand {
     return resolvedPromiseLike$3(void 0);
   }
 }
-function buildServiceDescriptor$f() {
+function buildServiceDescriptor$g() {
   return {
     type: "httpNormalizedCacheControlCommand",
     version: "1.0",
@@ -1537,7 +1537,7 @@ _FetchNetworkCommand.availableDecorators = {
   abortable: createAbortableDecorator
 };
 let FetchNetworkCommand = _FetchNetworkCommand;
-function buildServiceDescriptor$e() {
+function buildServiceDescriptor$f() {
   return {
     type: "fetchNetworkCommandBaseClass",
     version: "1.0",
@@ -1573,7 +1573,7 @@ class StreamingCommand extends BaseCommand {
     );
   }
 }
-function buildServiceDescriptor$d() {
+function buildServiceDescriptor$e() {
   return {
     type: "streamingCommandBaseClass",
     version: "1.0",
@@ -1656,7 +1656,7 @@ class SSEParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$c() {
+function buildServiceDescriptor$d() {
   return {
     type: "SSECommandBaseClass",
     version: "1.0",
@@ -1707,7 +1707,7 @@ function buildInstrumentCommand(services) {
     };
   };
 }
-function buildServiceDescriptor$b(instrumentation) {
+function buildServiceDescriptor$c(instrumentation) {
   return {
     type: "instrumentCommand",
     version: "1.0",
@@ -1977,7 +1977,7 @@ class O11yInstrumentation {
     this.metrics = new O11yOTelMetricsAPI(this.services);
   }
 }
-function buildServiceDescriptor$a(logger) {
+function buildServiceDescriptor$b(logger) {
   return {
     type: "instrumentation",
     version: "1.0",
@@ -1995,12 +1995,12 @@ function buildServiceDescriptor$a(logger) {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-const { stringify: stringify$1, parse } = JSON;
-function deepCopy(x) {
-  const stringified = stringify$1(x);
-  return stringified ? parse(stringified) : void 0;
+const { stringify: stringify$2, parse: parse$1 } = JSON;
+function deepCopy$1(x) {
+  const stringified = stringify$2(x);
+  return stringified ? parse$1(stringified) : void 0;
 }
-class DefaultRecordableCache {
+let DefaultRecordableCache$1 = class DefaultRecordableCache {
   constructor(baseCache) {
     this.baseCache = baseCache;
     this.keysRead = /* @__PURE__ */ new Set();
@@ -2019,7 +2019,7 @@ class DefaultRecordableCache {
       this.missingKeysRead.add(key);
     }
     if (options == null ? void 0 : options.copy) {
-      return deepCopy(value);
+      return deepCopy$1(value);
     }
     return value;
   }
@@ -2045,13 +2045,13 @@ class DefaultRecordableCache {
     return new DefaultRecordableCache(this);
   }
   filter(predicate) {
-    return new DefaultFilteredCache(this, predicate);
+    return new DefaultFilteredCache$1(this, predicate);
   }
   buildFixedTimeWritableCache(generatedTime) {
-    return new FixedTimeWritableCache(this, generatedTime);
+    return new FixedTimeWritableCache$1(this, generatedTime);
   }
-}
-class DefaultFilteredCache {
+};
+let DefaultFilteredCache$1 = class DefaultFilteredCache {
   constructor(baseCache, predicate) {
     this.baseCache = baseCache;
     this.predicate = predicate;
@@ -2063,7 +2063,7 @@ class DefaultFilteredCache {
     const result = this.baseCache.get(key);
     if (result && this.predicate(key, result)) {
       if (options == null ? void 0 : options.copy) {
-        return deepCopy(result);
+        return deepCopy$1(result);
       }
       return result;
     }
@@ -2085,7 +2085,7 @@ class DefaultFilteredCache {
     return this.getFilteredEntries();
   }
   record() {
-    return new DefaultRecordableCache(this);
+    return new DefaultRecordableCache$1(this);
   }
   filter(predicate) {
     return new DefaultFilteredCache(this, predicate);
@@ -2105,10 +2105,10 @@ class DefaultFilteredCache {
     return filteredKeySet;
   }
   buildFixedTimeWritableCache(generatedTime) {
-    return new FixedTimeWritableCache(this, generatedTime);
+    return new FixedTimeWritableCache$1(this, generatedTime);
   }
-}
-class FixedTimeWritableCache {
+};
+let FixedTimeWritableCache$1 = class FixedTimeWritableCache {
   constructor(baseCache, generatedTime) {
     this.baseCache = baseCache;
     this.generatedTime = generatedTime;
@@ -2144,22 +2144,22 @@ class FixedTimeWritableCache {
     return this.baseCache.entries();
   }
   record() {
-    return new DefaultRecordableCache(this);
+    return new DefaultRecordableCache$1(this);
   }
   filter(predicate) {
-    return new DefaultFilteredCache(this, predicate);
+    return new DefaultFilteredCache$1(this, predicate);
   }
   buildFixedTimeWritableCache(generatedTime) {
     return new FixedTimeWritableCache(this, generatedTime);
   }
-}
-class DefaultCache {
+};
+let DefaultCache$1 = class DefaultCache {
   constructor() {
     this.data = {};
   }
   get(key, options) {
     if (options == null ? void 0 : options.copy) {
-      return deepCopy(this.data[key]);
+      return deepCopy$1(this.data[key]);
     }
     return this.data[key];
   }
@@ -2221,20 +2221,20 @@ class DefaultCache {
     return Object.entries(this.data);
   }
   record() {
-    return new DefaultRecordableCache(this);
+    return new DefaultRecordableCache$1(this);
   }
   filter(predicate) {
-    return new DefaultFilteredCache(this, predicate);
+    return new DefaultFilteredCache$1(this, predicate);
   }
   buildFixedTimeWritableCache(generatedTime) {
-    return new FixedTimeWritableCache(this, generatedTime);
+    return new FixedTimeWritableCache$1(this, generatedTime);
   }
-}
-function buildServiceDescriptor$9() {
+};
+function buildServiceDescriptor$a() {
   return {
     type: "cache",
     version: "1.0",
-    service: new DefaultCache()
+    service: new DefaultCache$1()
   };
 }
 
@@ -2453,7 +2453,7 @@ class CacheController {
     yield* this.services.cacheInclusionPolicy.findAndModify(query, cacheUpdate);
   }
 }
-function buildServiceDescriptor$8(cache, cacheInclusionPolicy, instrumentation) {
+function buildServiceDescriptor$9(cache, cacheInclusionPolicy, instrumentation) {
   return {
     type: "cacheController",
     version: "1.0",
@@ -2563,7 +2563,7 @@ class DefaultPubSubService {
     return matchingSubscriptions;
   }
 }
-function buildServiceDescriptor$7() {
+function buildServiceDescriptor$8() {
   return {
     type: "pubSub",
     version: "1.0",
@@ -2626,7 +2626,7 @@ class NDJSONParsingStream extends TransformStream {
     });
   }
 }
-function buildServiceDescriptor$6() {
+function buildServiceDescriptor$7() {
   return {
     type: "NDJSONCommandBaseClass",
     version: "1.0",
@@ -2667,7 +2667,7 @@ function buildServiceDescriptor$6() {
  * };
  * ```
  */
-function buildServiceDescriptor$5(luvio) {
+function buildServiceDescriptor$6(luvio) {
     return {
         type: 'luvio',
         version: '1.0',
@@ -2676,7 +2676,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.399.0-5ea4ae8437
+// version: 1.401.0-c620f9ffed
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -2840,7 +2840,7 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
     });
   }
 }
-function buildServiceDescriptor$4() {
+function buildServiceDescriptor$5() {
   return {
     type: "auraGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2958,7 +2958,7 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
     });
   }
 }
-function buildServiceDescriptor$3() {
+function buildServiceDescriptor$4() {
   return {
     type: "httpGraphQLNormalizedCacheControlCommand",
     version: "1.0",
@@ -2982,7 +2982,7 @@ class FeatureFlagsService {
     return this.flags.get(flagName) || defaultValue;
   }
 }
-function buildServiceDescriptor$2() {
+function buildServiceDescriptor$3() {
   return {
     version: "1.0",
     service: new FeatureFlagsService(),
@@ -3004,7 +3004,7 @@ function buildServiceDescriptor$2() {
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
+function buildServiceDescriptor$2(notifyRecordUpdateAvailable, getNormalizedLuvioRecord) {
     return {
         type: 'luvioUiapiRecords',
         version: '1.0',
@@ -3014,7 +3014,7 @@ function buildServiceDescriptor$1(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.399.0-5ea4ae8437
+// version: 1.401.0-c620f9ffed
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3058,7 +3058,7 @@ class RetryService {
 }
 class RetryPolicy {
 }
-function buildServiceDescriptor(defaultRetryPolicy) {
+function buildServiceDescriptor$1(defaultRetryPolicy) {
   return {
     version: "1.0",
     service: new RetryService(defaultRetryPolicy),
@@ -4001,7 +4001,7 @@ function getEnvironmentSetting(name) {
     }
     return undefined;
 }
-// version: 1.399.0-5ea4ae8437
+// version: 1.401.0-c620f9ffed
 
 /**
  * Observability / Critical Availability Program (230+)
@@ -4051,7 +4051,7 @@ const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = {
 
 const { create, keys, hasOwnProperty, entries } = Object;
 const { isArray, from } = Array;
-const { stringify } = JSON;
+const { stringify: stringify$1 } = JSON;
 
 /**
  * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
@@ -4077,7 +4077,7 @@ function stableJSONStringify$1(node) {
         return isFinite(node) ? '' + node : 'null';
     }
     if (typeof node !== 'object') {
-        return stringify(node);
+        return stringify$1(node);
     }
     let i;
     let out;
@@ -4108,7 +4108,7 @@ function stableJSONStringify$1(node) {
         if (out) {
             out += ',';
         }
-        out += stringify(key) + ':' + value;
+        out += stringify$1(key) + ':' + value;
     }
     return '{' + out + '}';
 }
@@ -6001,7 +6001,7 @@ function stableJSONStringify(node) {
         return isFinite(node) ? '' + node : 'null';
     }
     if (typeof node !== 'object') {
-        return stringify(node);
+        return stringify$1(node);
     }
     let i;
     let out;
@@ -6029,7 +6029,7 @@ function stableJSONStringify(node) {
         if (out) {
             out += ',';
         }
-        out += stringify(key) + ':' + value;
+        out += stringify$1(key) + ':' + value;
     }
     return '{' + out + '}';
 }
@@ -7303,6 +7303,15 @@ class Ok {
   }
 }
 const ok = (value) => new Ok(value);
+function setDifference(setA, setB) {
+  const differenceSet = /* @__PURE__ */ new Set();
+  for (const element of setA) {
+    if (!setB.has(element)) {
+      differenceSet.add(element);
+    }
+  }
+  return differenceSet;
+}
 function resolvedPromiseLike(result) {
   if (isPromiseLike(result)) {
     return result.then((nextResult) => nextResult);
@@ -7340,6 +7349,303 @@ function rejectedPromiseLike(reason) {
 function isPromiseLike(x) {
   return typeof (x == null ? void 0 : x.then) === "function";
 }
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+/*!
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+const { stringify, parse } = JSON;
+function deepCopy(x) {
+  const stringified = stringify(x);
+  return stringified ? parse(stringified) : void 0;
+}
+class DefaultRecordableCache {
+  constructor(baseCache) {
+    this.baseCache = baseCache;
+    this.keysRead = /* @__PURE__ */ new Set();
+    this.missingKeysRead = /* @__PURE__ */ new Set();
+    this.keysUpdated = /* @__PURE__ */ new Set();
+    this.metadataKeysUpdated = /* @__PURE__ */ new Set();
+  }
+  delete(key) {
+    this.keysUpdated.add(key);
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    this.keysRead.add(key);
+    const value = this.baseCache.get(key);
+    if (value === void 0) {
+      this.missingKeysRead.add(key);
+    }
+    if (options == null ? void 0 : options.copy) {
+      return deepCopy(value);
+    }
+    return value;
+  }
+  set(key, value) {
+    this.keysUpdated.add(key);
+    this.metadataKeysUpdated.add(key);
+    this.baseCache.set(key, value);
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.metadataKeysUpdated.add(key);
+    this.baseCache.setMetadata(key, cacheControlMetadata);
+  }
+  length() {
+    return this.baseCache.length();
+  }
+  keys() {
+    return this.baseCache.keys();
+  }
+  entries() {
+    return this.baseCache.entries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class DefaultFilteredCache {
+  constructor(baseCache, predicate) {
+    this.baseCache = baseCache;
+    this.predicate = predicate;
+  }
+  delete(key) {
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    const result = this.baseCache.get(key);
+    if (result && this.predicate(key, result)) {
+      if (options == null ? void 0 : options.copy) {
+        return deepCopy(result);
+      }
+      return result;
+    }
+    return void 0;
+  }
+  set(key, value) {
+    this.baseCache.set(key, value);
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.baseCache.setMetadata(key, cacheControlMetadata);
+  }
+  length() {
+    return this.getFilteredKeys().size;
+  }
+  keys() {
+    return this.getFilteredKeys();
+  }
+  entries() {
+    return this.getFilteredEntries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  getFilteredEntries() {
+    return this.baseCache.entries().filter(([key, _value]) => {
+      return this.get(key);
+    });
+  }
+  getFilteredKeys() {
+    const filteredKeySet = /* @__PURE__ */ new Set();
+    this.baseCache.keys().forEach((key) => {
+      if (this.get(key)) {
+        filteredKeySet.add(key);
+      }
+    });
+    return filteredKeySet;
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class FixedTimeWritableCache {
+  constructor(baseCache, generatedTime) {
+    this.baseCache = baseCache;
+    this.generatedTime = generatedTime;
+  }
+  delete(key) {
+    this.baseCache.delete(key);
+  }
+  get(key, options) {
+    return this.baseCache.get(key, options);
+  }
+  set(key, value) {
+    this.baseCache.set(key, {
+      ...value,
+      metadata: {
+        ...value.metadata,
+        cacheControl: { ...value.metadata.cacheControl, generatedTime: this.generatedTime }
+      }
+    });
+  }
+  setMetadata(key, cacheControlMetadata) {
+    this.baseCache.setMetadata(key, {
+      ...cacheControlMetadata,
+      generatedTime: this.generatedTime
+    });
+  }
+  length() {
+    return this.baseCache.length();
+  }
+  keys() {
+    return this.baseCache.keys();
+  }
+  entries() {
+    return this.baseCache.entries();
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+class DefaultCache {
+  constructor() {
+    this.data = {};
+  }
+  get(key, options) {
+    if (options == null ? void 0 : options.copy) {
+      return deepCopy(this.data[key]);
+    }
+    return this.data[key];
+  }
+  /**
+   * Adds the specified key/value to the cache.
+   *
+   * @param key key at which to store value
+   * @param entry value to be stored
+   */
+  set(key, entry) {
+    if (entry.metadata.cacheControl.type === "no-store") {
+      return;
+    }
+    this.data[key] = {
+      ...entry,
+      metadata: {
+        ...entry.metadata,
+        type: entry.metadata.type || {
+          namespace: "OneStore:Internal",
+          name: "UnknownType"
+        },
+        cacheControl: {
+          generatedTime: Date.now() / 1e3,
+          ...entry.metadata.cacheControl
+        }
+      }
+    };
+  }
+  /**
+   * Removes the cache entry associated with the specified key.
+   *
+   * @param key key to be removed from the store
+   */
+  delete(key) {
+    delete this.data[key];
+  }
+  /**
+   * Sets the metadata for the specified key if the key is in cache.
+   * If the key doesn't exist, it does nothing.
+   *
+   * @param key key at which to store metadata
+   * @param cacheControlMetadata metadata to be stored
+   */
+  setMetadata(key, cacheControlMetadata) {
+    if (key in this.data) {
+      this.data[key].metadata.cacheControl = {
+        generatedTime: Date.now() / 1e3,
+        ...cacheControlMetadata
+      };
+    }
+  }
+  length() {
+    return this.keys().size;
+  }
+  keys() {
+    return new Set(Object.keys(this.data));
+  }
+  entries() {
+    return Object.entries(this.data);
+  }
+  record() {
+    return new DefaultRecordableCache(this);
+  }
+  filter(predicate) {
+    return new DefaultFilteredCache(this, predicate);
+  }
+  buildFixedTimeWritableCache(generatedTime) {
+    return new FixedTimeWritableCache(this, generatedTime);
+  }
+}
+function buildServiceDescriptor() {
+  return {
+    type: "cache",
+    version: "1.0",
+    service: new DefaultCache()
+  };
+}
+class DurableCacheInclusionPolicy extends CacheInclusionPolicyService {
+  /**
+   * Reads data out of a 2 level inclusive store.
+   */
+  read(options) {
+    const { l1, readFromL1, alreadyRevivedKeys } = options;
+    const recordableCache = l1.record();
+    return readFromL1(recordableCache).then((readResult) => {
+      if (readResult.isOk()) {
+        return readResult;
+      }
+      const keysToRevive = recordableCache.keysRead;
+      if (alreadyRevivedKeys && setDifference(keysToRevive, alreadyRevivedKeys).size === 0) {
+        return readResult;
+      }
+      return this.revive(keysToRevive, l1).then((revivedKeys) => {
+        if (setDifference(keysToRevive, revivedKeys).size > 0) {
+          return readResult;
+        }
+        return this.read({ l1, readFromL1, alreadyRevivedKeys: revivedKeys });
+      });
+    });
+  }
+  /**
+   * Writes data to a 2 level inclusive store.
+   */
+  write(options) {
+    const { l1, writeToL1 } = options;
+    const tempL1 = buildServiceDescriptor().service.record();
+    return writeToL1(tempL1).then(() => {
+      const keysToReviveRecordableCache = l1.record();
+      tempL1.keysUpdated.forEach((key) => keysToReviveRecordableCache.get(key));
+      tempL1.missingKeysRead.forEach((key) => keysToReviveRecordableCache.get(key));
+      const missingKeys = keysToReviveRecordableCache.missingKeysRead;
+      const revivePromiseLike = missingKeys.size > 0 ? this.revive(missingKeys, l1).then(() => void 0) : resolvedPromiseLike(void 0);
+      return revivePromiseLike.then(() => {
+        const recordableCache = l1.record();
+        return writeToL1(recordableCache).then((result) => {
+          this.syncToL2Cache(recordableCache.keysUpdated, l1);
+          return result;
+        });
+      });
+    });
+  }
+}
 const isAndQuery = (query) => "$and" in query;
 const isOrQuery = (query) => "$or" in query;
 const isNotQuery = (query) => "$not" in query;
@@ -7533,6 +7839,314 @@ class FetchThrottlingRetryPolicy extends RetryPolicy {
     }
 }
 
+/**
+ * Default storage configuration for the durable cache
+ */
+const DEFAULT_STORAGE_CONFIG = {
+    name: 'ldsDurableCache',
+    persistent: true,
+    secure: true,
+    maxSize: 10 * 1024 * 1024,
+    expiration: 30 * 24 * 60 * 60,
+    clearOnInit: false,
+    debugLogging: false,
+};
+/**
+ * Durable cache inclusion policy that uses AuraStorage for persistent L2 cache
+ */
+class AuraDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
+    constructor(config = {}) {
+        super();
+        // Create storage with merged configuration
+        const storageConfig = {
+            ...DEFAULT_STORAGE_CONFIG,
+            ...config,
+        };
+        this.storage = createStorage(storageConfig);
+        if (!this.storage) {
+            console.warn('Failed to create durable storage for cache inclusion policy');
+        }
+    }
+    /**
+     * Revive cache entries from AuraStorage into L1 cache
+     * @param keys - Set of keys to revive
+     * @param l1 - L1 cache instance
+     * @returns Set of keys that were successfully revived
+     */
+    async revive(keys, l1) {
+        if (keys.size === 0 || !this.storage) {
+            return new Set();
+        }
+        const revivedKeys = new Set();
+        try {
+            // Convert keys to array of strings for getAll()
+            const keysArray = Array.from(keys).map((key) => key);
+            // Get only the requested entries using getAll() with specific keys
+            const storedData = (await this.storage.getAll(keysArray));
+            // Process the retrieved cache entries
+            for (const [storageKey, storedEntry] of Object.entries(storedData)) {
+                const key = storageKey;
+                const entry = storedEntry;
+                if (entry) {
+                    l1.set(key, entry);
+                    revivedKeys.add(key);
+                }
+            }
+        }
+        catch (error) {
+            // Log error but don't fail the operation
+            console.warn('Failed to revive cache entries from AuraStorage:', error);
+        }
+        return revivedKeys;
+    }
+    /**
+     * Sync changed keys from L1 cache to AuraStorage (L2 cache)
+     * @param changedKeys - Set of keys that have changed
+     * @param l1 - L1 cache instance
+     */
+    async syncToL2Cache(changedKeys, l1) {
+        if (changedKeys.size === 0 || !this.storage) {
+            return;
+        }
+        const promises = [];
+        for (const key of changedKeys) {
+            const storageKey = key;
+            const entry = l1.get(key);
+            if (entry) {
+                // Add or update the entry
+                promises.push(this.storage.set(storageKey, entry).catch((error) => {
+                    console.warn(`Failed to persist cache entry: ${storageKey}`, error);
+                }));
+            }
+            else {
+                // Remove the entry if it doesn't exist in L1
+                promises.push(this.storage
+                    .remove(storageKey)
+                    .catch((error) => {
+                    console.warn(`Failed to remove cache entry: ${storageKey}`, error);
+                })
+                    .then(() => { }));
+            }
+        }
+        await Promise.all(promises);
+    }
+    /**
+     * Find entries matching a query
+     * @param query - Cache query to match entries
+     */
+    async *find(query) {
+        if (!this.storage) {
+            return;
+        }
+        try {
+            // Need to get all entries to search through them with the query
+            // Cannot pass specific keys since we don't know which entries match the query
+            const allStoredData = (await this.storage.getAll());
+            // Iterate through all cache entries and yield those matching the query
+            for (const [storageKey, storedEntry] of Object.entries(allStoredData)) {
+                const entry = storedEntry;
+                const key = storageKey;
+                if (entry && this.matchesQuery(key, entry, query)) {
+                    yield [key, entry];
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to find cache entries in AuraStorage:', error);
+        }
+    }
+    /**
+     * Find and modify entries matching a query
+     * @param query - Cache query to match entries
+     * @param cacheUpdate - Update to apply to matching entries
+     */
+    async *findAndModify(query, cacheUpdate) {
+        if (!this.storage) {
+            return;
+        }
+        try {
+            // Need to get all entries to search through them with the query
+            // Cannot pass specific keys since we don't know which entries match the query
+            const allStoredData = (await this.storage.getAll());
+            const modifiedEntries = [];
+            // Find and modify matching entries
+            for (const [storageKey, storedEntry] of Object.entries(allStoredData)) {
+                const entry = storedEntry;
+                const key = storageKey;
+                if (entry && this.matchesQuery(key, entry, query)) {
+                    // Apply the update to the entry
+                    const updatedEntry = this.applyUpdate(entry, cacheUpdate);
+                    if (updatedEntry) {
+                        modifiedEntries.push({ storageKey, entry: updatedEntry, modifiedKey: key });
+                    }
+                }
+            }
+            // Save all modified entries back to storage
+            if (modifiedEntries.length > 0 && this.storage) {
+                const promises = modifiedEntries.map(({ storageKey, entry }) => this.storage.set(storageKey, entry).catch((error) => {
+                    console.warn(`Failed to update cache entry: ${storageKey}`, error);
+                }));
+                await Promise.all(promises);
+                // Yield all modified keys
+                for (const { modifiedKey } of modifiedEntries) {
+                    yield modifiedKey;
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to find and modify cache entries in AuraStorage:', error);
+        }
+    }
+    /**
+     * Check if an entry matches a cache query
+     * @param key - Cache key to check
+     * @param entry - Cache entry to check
+     * @param query - Query to match against
+     * @returns true if the entry matches the query
+     */
+    matchesQuery(key, entry, query) {
+        if (!query)
+            return true;
+        // Handle logical operators
+        if (this.isAndQuery(query)) {
+            return query.$and.every((subQuery) => this.matchesQuery(key, entry, subQuery));
+        }
+        if (this.isOrQuery(query)) {
+            return query.$or.some((subQuery) => this.matchesQuery(key, entry, subQuery));
+        }
+        if (this.isNotQuery(query)) {
+            return !this.matchesQuery(key, entry, query.$not);
+        }
+        // Handle specific query types
+        if ('key' in query) {
+            return this.matchesKey(query.key, key);
+        }
+        if ('metadata' in query) {
+            return this.matchesMetadata(query.metadata, entry.metadata.cacheControl);
+        }
+        if ('value' in query) {
+            return false; // Value-based querying not implemented
+        }
+        return false; // Unknown query type
+    }
+    isAndQuery(query) {
+        return '$and' in query;
+    }
+    isOrQuery(query) {
+        return '$or' in query;
+    }
+    isNotQuery(query) {
+        return '$not' in query;
+    }
+    matchesKey(keyQuery, key) {
+        if ('$regex' in keyQuery) {
+            const keyString = typeof key === 'string' ? key : JSON.stringify(key);
+            return keyQuery.$regex.test(keyString);
+        }
+        return false;
+    }
+    matchesMetadata(metadataQuery, cacheControl) {
+        if ('cacheControlType' in metadataQuery &&
+            cacheControl.type !== metadataQuery.cacheControlType.$eq) {
+            return false;
+        }
+        if ('maxAge' in metadataQuery && cacheControl.type === 'max-age') {
+            const maxAge = cacheControl.maxAge ?? 0;
+            if ((metadataQuery.maxAge.$gte !== undefined && maxAge < metadataQuery.maxAge.$gte) ||
+                (metadataQuery.maxAge.$lte !== undefined && maxAge > metadataQuery.maxAge.$lte)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Apply an update to a cache entry
+     * @param entry - Original cache entry
+     * @param update - Update to apply
+     * @returns Updated entry or null if no update needed
+     */
+    applyUpdate(entry, update) {
+        try {
+            const updateResult = this.buildUpdate(update, entry);
+            switch (updateResult.type) {
+                case 'entry':
+                    return updateResult.entry;
+                case 'metadata':
+                    // Create a new entry with updated metadata
+                    return {
+                        ...entry,
+                        metadata: {
+                            ...entry.metadata,
+                            cacheControl: updateResult.metadata,
+                        },
+                    };
+                case 'no-op':
+                    return null; // No changes needed
+                default:
+                    return null;
+            }
+        }
+        catch (error) {
+            console.warn('Failed to apply update to cache entry:', error);
+            return null;
+        }
+    }
+    /**
+     * Build an update for a cache entry
+     * @param update - The cache update operation to apply
+     * @param existing - The existing cache entry being modified
+     * @returns An object indicating the type of update
+     */
+    buildUpdate(update, existing) {
+        switch (update.type) {
+            case 'invalidate':
+                const updatedCacheControl = this.buildInvalidatedCacheControl(existing.metadata.cacheControl);
+                return updatedCacheControl !== undefined
+                    ? { type: 'metadata', metadata: updatedCacheControl }
+                    : { type: 'no-op' };
+            default:
+                throw new Error(`Invalid update operation: ${update.type}`);
+        }
+    }
+    /**
+     * Build an invalidated cache control metadata
+     * @param existingCacheControl - The current CacheControlMetadata
+     * @returns A new CacheControlMetadata object with maxAge set to 0, or undefined if no changes needed
+     */
+    buildInvalidatedCacheControl(existingCacheControl) {
+        switch (existingCacheControl.type) {
+            case 'max-age':
+            case 'stale-while-revalidate':
+                if (existingCacheControl.maxAge !== 0) {
+                    return {
+                        ...existingCacheControl,
+                        maxAge: 0,
+                    };
+                }
+                return undefined; // Already invalidated
+            case 'no-cache':
+            case 'no-store':
+                // These types don't need invalidation
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+}
+/**
+ * Factory function to create an AuraDurableCacheInclusionPolicy service descriptor
+ * @param config - Optional configuration for the storage
+ * @returns Service descriptor for the cache inclusion policy
+ */
+function buildAuraDurableCacheInclusionPolicyService(config) {
+    return {
+        service: new AuraDurableCacheInclusionPolicy(config),
+        type: 'cacheInclusionPolicy',
+        version: '1.0',
+        tags: { storage: 'durable' },
+    };
+}
+
 // 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
@@ -7794,12 +8408,17 @@ function initializeLDS() {
 // Initializes OneStore in LEX
 function initializeOneStore(luvio) {
     const loggerService = new ConsoleLogger$1('ERROR');
-    const cacheServiceDescriptor = buildServiceDescriptor$9();
-    const instrumentationServiceDescriptor = buildServiceDescriptor$a(loggerService);
+    const cacheServiceDescriptor = buildServiceDescriptor$a();
+    const instrumentationServiceDescriptor = buildServiceDescriptor$b(loggerService);
     const inMemoryCacheInclusionPolicyServiceDescriptor = buildInMemoryCacheInclusionPolicyService(cacheServiceDescriptor.service);
-    const featureFlagsServiceDescriptor = buildServiceDescriptor$2();
+    const durableCacheInclusionPolicyServiceDescriptor = buildAuraDurableCacheInclusionPolicyService();
+    const durableCacheControlService = {
+        ...buildServiceDescriptor$9(cacheServiceDescriptor.service, durableCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
+        tags: { storage: 'durable' },
+    };
+    const featureFlagsServiceDescriptor = buildServiceDescriptor$3();
     const featureFlagsService = featureFlagsServiceDescriptor.service;
-    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$1((configs) => {
+    const luvioUiapiRecordsServiceDescriptor = buildServiceDescriptor$2((configs) => {
         return notifyUpdateAvailableFactory(luvio)(configs);
     }, (recordId, reader) => {
         const recordKey = buildRecordRepKeyFromId(recordId);
@@ -7819,7 +8438,7 @@ function initializeOneStore(luvio) {
         return linkedData.data;
     });
     const retryPolicy = new FetchThrottlingRetryPolicy();
-    const retryServiceDescriptor = buildServiceDescriptor(retryPolicy);
+    const retryServiceDescriptor = buildServiceDescriptor$1(retryPolicy);
     const retryService = retryServiceDescriptor.service;
     // set flags based on gates
     featureFlagsService.set('useOneStoreGraphQL', useOneStoreGraphql.isOpen({ fallback: false }));
@@ -7830,23 +8449,25 @@ function initializeOneStore(luvio) {
         buildJwtAuthorizedSfapFetchServiceDescriptor(loggerService),
         buildCopilotFetchServiceDescriptor(loggerService),
         buildAuraNetworkService(),
-        buildServiceDescriptor$b(instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$8(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
-        buildServiceDescriptor$i(),
-        buildServiceDescriptor$6(),
-        buildServiceDescriptor$e(),
+        buildServiceDescriptor$c(instrumentationServiceDescriptor.service),
+        // Ordering of services matters - L1 only CacheControlService must come before durable
+        buildServiceDescriptor$9(cacheServiceDescriptor.service, inMemoryCacheInclusionPolicyServiceDescriptor.service, instrumentationServiceDescriptor.service),
+        durableCacheControlService,
         buildServiceDescriptor$j(),
+        buildServiceDescriptor$7(),
+        buildServiceDescriptor$f(),
+        buildServiceDescriptor$k(),
+        buildServiceDescriptor$e(),
         buildServiceDescriptor$d(),
-        buildServiceDescriptor$c(),
+        buildServiceDescriptor$i(),
         buildServiceDescriptor$h(),
         buildServiceDescriptor$g(),
-        buildServiceDescriptor$f(),
-        buildServiceDescriptor$7(),
+        buildServiceDescriptor$8(),
         buildLexRuntimeAllow5xxFetchServiceDescriptor(loggerService, retryService),
-        buildServiceDescriptor$5(luvio),
+        buildServiceDescriptor$6(luvio),
         luvioUiapiRecordsServiceDescriptor,
+        buildServiceDescriptor$5(),
         buildServiceDescriptor$4(),
-        buildServiceDescriptor$3(),
         featureFlagsServiceDescriptor,
         retryServiceDescriptor,
     ];
@@ -7868,4 +8489,4 @@ function ldsEngineCreator() {
 }
 
 export { LexRequestStrategy, PdlRequestPriority, buildPredictorForContext, ldsEngineCreator as default, initializeLDS, initializeOneStore, notifyUpdateAvailableFactory, registerRequestStrategy, saveRequestAsPrediction, unregisterRequestStrategy, whenPredictionsReady };
-// version: 1.399.0-c92b32e0bf
+// version: 1.401.0-b1adb82748

package/dist/types/__mocks__/@salesforce/lds-aura-storage.d.ts

@@ -1 +1,6 @@
 export declare function clearStorages(): Promise<void>;
+export declare function createStorage(): {
+    getAll: jest.Mock<any, any, any>;
+    get: jest.Mock<any, any, any>;
+    set: jest.Mock<any, any, any>;
+};

package/dist/types/service-variants/durable-cache-inclusion-policy.d.ts

@@ -0,0 +1,78 @@
+import { type AuraStorageConfig } from '@salesforce/lds-aura-storage';
+import { type CacheInclusionPolicyServiceDescriptor, type CacheQuery, type CacheUpdate, DurableCacheInclusionPolicy } from '@conduit-client/service-cache-inclusion-policy/v1';
+import type { Cache, CacheEntry, Key } from '@conduit-client/service-cache/v1';
+import type { DeepReadonly } from '@conduit-client/utils';
+/**
+ * Configuration options for AuraDurableCacheInclusionPolicy
+ */
+export type DurableCacheConfig = Partial<AuraStorageConfig>;
+/**
+ * Durable cache inclusion policy that uses AuraStorage for persistent L2 cache
+ */
+export declare class AuraDurableCacheInclusionPolicy extends DurableCacheInclusionPolicy {
+    private readonly storage;
+    constructor(config?: DurableCacheConfig);
+    /**
+     * Revive cache entries from AuraStorage into L1 cache
+     * @param keys - Set of keys to revive
+     * @param l1 - L1 cache instance
+     * @returns Set of keys that were successfully revived
+     */
+    revive(keys: Set<Key>, l1: Cache): Promise<Set<Key>>;
+    /**
+     * Sync changed keys from L1 cache to AuraStorage (L2 cache)
+     * @param changedKeys - Set of keys that have changed
+     * @param l1 - L1 cache instance
+     */
+    syncToL2Cache(changedKeys: Set<Key>, l1: Cache): Promise<void>;
+    /**
+     * Find entries matching a query
+     * @param query - Cache query to match entries
+     */
+    find(query: CacheQuery): AsyncGenerator<[key: Key, value: DeepReadonly<CacheEntry<unknown>>], void, unknown>;
+    /**
+     * Find and modify entries matching a query
+     * @param query - Cache query to match entries
+     * @param cacheUpdate - Update to apply to matching entries
+     */
+    findAndModify(query: CacheQuery, cacheUpdate: CacheUpdate): AsyncGenerator<Key, void, unknown>;
+    /**
+     * Check if an entry matches a cache query
+     * @param key - Cache key to check
+     * @param entry - Cache entry to check
+     * @param query - Query to match against
+     * @returns true if the entry matches the query
+     */
+    private matchesQuery;
+    private isAndQuery;
+    private isOrQuery;
+    private isNotQuery;
+    private matchesKey;
+    private matchesMetadata;
+    /**
+     * Apply an update to a cache entry
+     * @param entry - Original cache entry
+     * @param update - Update to apply
+     * @returns Updated entry or null if no update needed
+     */
+    private applyUpdate;
+    /**
+     * Build an update for a cache entry
+     * @param update - The cache update operation to apply
+     * @param existing - The existing cache entry being modified
+     * @returns An object indicating the type of update
+     */
+    private buildUpdate;
+    /**
+     * Build an invalidated cache control metadata
+     * @param existingCacheControl - The current CacheControlMetadata
+     * @returns A new CacheControlMetadata object with maxAge set to 0, or undefined if no changes needed
+     */
+    private buildInvalidatedCacheControl;
+}
+/**
+ * Factory function to create an AuraDurableCacheInclusionPolicy service descriptor
+ * @param config - Optional configuration for the storage
+ * @returns Service descriptor for the cache inclusion policy
+ */
+export declare function buildAuraDurableCacheInclusionPolicyService(config?: DurableCacheConfig): CacheInclusionPolicyServiceDescriptor;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-aura",
-    "version": "1.399.0",
+    "version": "1.401.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS engine for Aura runtime",
     "main": "dist/ldsEngineCreator.js",
@@ -36,14 +36,14 @@
     "devDependencies": {
         "@conduit-client/service-provisioner": "2.0.1",
         "@conduit-client/tools-core": "2.0.1",
-        "@salesforce/lds-adapters-apex": "^1.399.0",
-        "@salesforce/lds-adapters-uiapi": "^1.399.0",
-        "@salesforce/lds-ads-bridge": "^1.399.0",
-        "@salesforce/lds-aura-storage": "^1.399.0",
-        "@salesforce/lds-bindings": "^1.399.0",
-        "@salesforce/lds-instrumentation": "^1.399.0",
-        "@salesforce/lds-network-aura": "^1.399.0",
-        "@salesforce/lds-network-fetch": "^1.399.0",
+        "@salesforce/lds-adapters-apex": "^1.401.0",
+        "@salesforce/lds-adapters-uiapi": "^1.401.0",
+        "@salesforce/lds-ads-bridge": "^1.401.0",
+        "@salesforce/lds-aura-storage": "^1.401.0",
+        "@salesforce/lds-bindings": "^1.401.0",
+        "@salesforce/lds-instrumentation": "^1.401.0",
+        "@salesforce/lds-network-aura": "^1.401.0",
+        "@salesforce/lds-network-fetch": "^1.401.0",
         "jwt-encode": "1.0.1"
     },
     "dependencies": {
@@ -71,10 +71,10 @@
         "@luvio/network-adapter-composable": "0.158.7",
         "@luvio/network-adapter-fetch": "0.158.7",
         "@lwc/state": "^0.23.0",
-        "@salesforce/lds-adapters-onestore-graphql": "^1.399.0",
-        "@salesforce/lds-adapters-uiapi-lex": "^1.399.0",
-        "@salesforce/lds-luvio-service": "^1.399.0",
-        "@salesforce/lds-luvio-uiapi-records-service": "^1.399.0"
+        "@salesforce/lds-adapters-onestore-graphql": "^1.401.0",
+        "@salesforce/lds-adapters-uiapi-lex": "^1.401.0",
+        "@salesforce/lds-luvio-service": "^1.401.0",
+        "@salesforce/lds-luvio-uiapi-records-service": "^1.401.0"
     },
     "luvioBundlesize": [
         {