@salesforce/lds-adapters-uiapi 1.444.0 → 1.445.0

package/dist/es/es2018/uiapi-records-service.js

@@ -3993,7 +3993,7 @@ function mergeAndRefreshLowerVersionRecord(luvio, incoming, existing, incomingTr
             };
         }
         else {
-            buildNetworkSnapshot$1b(luvio, {
+            buildNetworkSnapshot$1f(luvio, {
                 recordId: incoming.id,
                 optionalFields: convertTrieToFields(incomingTrackedFieldsTrieRoot),
             });
@@ -4477,7 +4477,7 @@ function buildRecordSelector(luvio, recordId, fields, optionalFields) {
 function buildSnapshotRefresh$5(luvio, config) {
     return {
         config,
-        resolve: () => buildNetworkSnapshot$1b(luvio, config),
+        resolve: () => buildNetworkSnapshot$1f(luvio, config),
     };
 }
 function prepareRequest$7(luvio, config) {
@@ -4522,7 +4522,7 @@ function onResourceError(luvio, config, key, err) {
     const errorSnapshot = ingestError$R(luvio, config, key, err);
     return luvio.storeBroadcast().then(() => errorSnapshot);
 }
-function buildNetworkSnapshot$1b(luvio, config, serverRequestCount = 0, options) {
+function buildNetworkSnapshot$1f(luvio, config, serverRequestCount = 0, options) {
     const { request, key, allTrackedFields, resourceParams } = prepareRequest$7(luvio, config);
     return luvio.dispatchResourceRequest(request, options).then((response) => {
         // W-11964675 - Condition to dedupe a very specific set of requests for
@@ -4579,7 +4579,7 @@ function buildNetworkSnapshotCachePolicy$W(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$1b(luvio, config, 0, dispatchOptions);
+    return buildNetworkSnapshot$1f(luvio, config, 0, dispatchOptions);
 }
 function getRecordByFields(luvio, config, requestContext) {
     return luvio.applyCachePolicy(requestContext || {}, { config, luvio }, buildCachedSnapshotCachePolicy$V, buildNetworkSnapshotCachePolicy$W);
@@ -4942,7 +4942,7 @@ function onFetchResponseSuccess$S(luvio, config, resourceParams, response, serve
         },
         refresh: {
             config,
-            resolve: () => buildNetworkSnapshot$1a(luvio, config, serverRequestCount, snapshotRefreshOptions),
+            resolve: () => buildNetworkSnapshot$1e(luvio, config, serverRequestCount, snapshotRefreshOptions),
         },
         variables: {},
     };
@@ -4952,11 +4952,11 @@ function onFetchResponseSuccess$S(luvio, config, resourceParams, response, serve
 function onFetchResponseError$T(luvio, config, resourceParams, response) {
     const snapshot = ingestError$Q(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$1a(luvio, config, 0, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$1e(luvio, config, 0, snapshotRefreshOptions),
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$1a(luvio, config, serverRequestCount = 0, options) {
+function buildNetworkSnapshot$1e(luvio, config, serverRequestCount = 0, options) {
     const resourceParams = createResourceParams$14(config);
     const request = createResourceRequest$1f(resourceParams);
     return luvio.dispatchResourceRequest(request, options).then((response) => {
@@ -4983,7 +4983,7 @@ function resolveConflict(luvio, map) {
             recordId,
             optionalFields: convertTrieToFields(map.conflicts[recordId].trackedFields),
         };
-        buildNetworkSnapshot$1b(luvio, config, map.serverRequestCount);
+        buildNetworkSnapshot$1f(luvio, config, map.serverRequestCount);
     }
     else {
         const records = reduce.call(ids, (acc, id) => {
@@ -4995,7 +4995,7 @@ function resolveConflict(luvio, map) {
             return acc;
         }, []);
         const config = { records };
-        buildNetworkSnapshot$1a(luvio, config, map.serverRequestCount);
+        buildNetworkSnapshot$1e(luvio, config, map.serverRequestCount);
     }
 }
 
@@ -6237,18 +6237,18 @@ function adapterFragment$N(luvio, config) {
 function onFetchResponseSuccess$R(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$W(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$19(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1d(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$S(luvio, config, resourceParams, response) {
     const snapshot = ingestError$P(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$19(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1d(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$19(luvio, config, options, cacheSnapshot) {
+function buildNetworkSnapshot$1d(luvio, config, options, cacheSnapshot) {
     const resourceParams = createResourceParams$13(config);
     const request = createResourceRequest$1e(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -6263,7 +6263,7 @@ function buildNetworkSnapshot$19(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$V(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$19, undefined, true);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$1d, undefined, true);
 }
 function buildCachedSnapshotCachePolicy$U(context, storeLookup) {
     const { luvio, config } = context;
@@ -6274,7 +6274,7 @@ function buildCachedSnapshotCachePolicy$U(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$19(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1d(luvio, config, snapshotRefreshOptions)
     });
     if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
         context.cacheSnapshot = cacheSnapshot;
@@ -6386,18 +6386,18 @@ function adapterFragment$M(luvio, config) {
 function onFetchResponseSuccess$Q(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$V(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$18(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$R(luvio, config, resourceParams, response) {
     const snapshot = ingestError$O(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$18(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1c(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$18(luvio, config, options, cacheSnapshot) {
+function buildNetworkSnapshot$1c(luvio, config, options, cacheSnapshot) {
     const resourceParams = createResourceParams$12(config);
     const request = createResourceRequest$1d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -6412,7 +6412,7 @@ function buildNetworkSnapshot$18(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$U(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$18, undefined, true);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$1c, undefined, true);
 }
 function buildCachedSnapshotCachePolicy$T(context, storeLookup) {
     const { luvio, config } = context;
@@ -6423,7 +6423,7 @@ function buildCachedSnapshotCachePolicy$T(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$18(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1c(luvio, config, snapshotRefreshOptions)
     });
     if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
         context.cacheSnapshot = cacheSnapshot;
@@ -8214,14 +8214,14 @@ function adapterFragment$L(luvio, config) {
 function onFetchResponseSuccess$P(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$T(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$17(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$Q(luvio, config, resourceParams, response) {
     const snapshot = ingestError$M(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$17(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
@@ -8300,7 +8300,7 @@ function getPaginationMetadata$3(luvio, resourceParams) {
     }
     return node.data.__metadata;
 }
-function buildNetworkSnapshot$17(luvio, config, options, cacheSnapshot) {
+function buildNetworkSnapshot$1b(luvio, config, options, cacheSnapshot) {
     const resourceParams = createResourceParams$11(config);
     const request = prepareRequest$6(luvio, config, resourceParams, cacheSnapshot);
     return luvio.dispatchResourceRequest(request, options)
@@ -8315,7 +8315,7 @@ function buildNetworkSnapshot$17(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$T(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$17, undefined, true);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$1b, undefined, true);
 }
 function buildCachedSnapshotCachePolicy$S(context, storeLookup) {
     const { luvio, config } = context;
@@ -8326,7 +8326,7 @@ function buildCachedSnapshotCachePolicy$S(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$17(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1b(luvio, config, snapshotRefreshOptions)
     });
     if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
         context.cacheSnapshot = cacheSnapshot;
@@ -10258,18 +10258,18 @@ function adapterFragment$K(luvio, config) {
 function onFetchResponseSuccess$O(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$S(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$16(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1a(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$P(luvio, config, resourceParams, response) {
     const snapshot = ingestError$L(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$16(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1a(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$16(luvio, config, options) {
+function buildNetworkSnapshot$1a(luvio, config, options) {
     const resourceParams = createResourceParams$$(config);
     const request = createResourceRequest$17(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -10284,7 +10284,7 @@ function buildNetworkSnapshot$16(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$S(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$16, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$1a, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$R(context, storeLookup) {
     const { luvio, config } = context;
@@ -10295,7 +10295,7 @@ function buildCachedSnapshotCachePolicy$R(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$16(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$1a(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -11581,7 +11581,7 @@ function keyBuilder$3y(recordIds, layoutTypes, modes, optionalFields) {
 function buildSnapshotRefresh$4(luvio, config) {
     return {
         config,
-        resolve: () => buildNetworkSnapshot$15(luvio, config),
+        resolve: () => buildNetworkSnapshot$19(luvio, config),
     };
 }
 function markRecordUiNulledOutLookupFields(recordLookupFields, recordNodes) {
@@ -11735,7 +11735,7 @@ function onFetchResponseError$O(luvio, config, selectorKey, key, err) {
         return errorSnapshot;
     });
 }
-function buildNetworkSnapshot$15(luvio, config, dispatchContext) {
+function buildNetworkSnapshot$19(luvio, config, dispatchContext) {
     const { key, resourceRequest, selectorKey } = prepareRequest$5(luvio, config);
     return luvio
         .dispatchResourceRequest(resourceRequest, dispatchContext)
@@ -11803,7 +11803,7 @@ function buildNetworkRecordUiRepresentationSnapshot(context, coercedAdapterReque
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$15(context.luvio, context.config, dispatchOptions);
+    return buildNetworkSnapshot$19(context.luvio, context.config, dispatchOptions);
 }
 function coerceConfigWithDefaults$3(untrustedConfig) {
     const config = validateAdapterConfig$16(untrustedConfig, GET_RECORDUI_ADAPTER_CONFIG);
@@ -11870,7 +11870,7 @@ function refresh(luvio, config) {
         modes,
         optionalFields,
     };
-    return buildNetworkSnapshot$15(luvio, recordUiConfig).then((snapshot) => {
+    return buildNetworkSnapshot$19(luvio, recordUiConfig).then((snapshot) => {
         const refresh = buildSnapshotRefresh$3(luvio, config);
         if (isErrorSnapshot(snapshot)) {
             var recordKey = keyBuilder$3U(luvio, { recordId });
@@ -12026,7 +12026,7 @@ function getRecord(luvio, refresh, recordId, fields, configOptionalFields) {
     }
     return recordSnapshotOrPromise;
 }
-function buildNetworkSnapshot$14(context, coercedAdapterRequestContext) {
+function buildNetworkSnapshot$18(context, coercedAdapterRequestContext) {
     const { config, luvio, adapterContext } = context;
     const { recordId } = config;
     const optionalFields = config.optionalFields === undefined ? [] : dedupe(config.optionalFields).sort();
@@ -12052,7 +12052,7 @@ function buildNetworkSnapshot$14(context, coercedAdapterRequestContext) {
             fields: context.fields,
             optionalFields,
         };
-        return buildNetworkSnapshot$1b(luvio, recordConfig, 0, coercedAdapterRequestContext).then((snapshot) => {
+        return buildNetworkSnapshot$1f(luvio, recordConfig, 0, coercedAdapterRequestContext).then((snapshot) => {
             snapshot.refresh = refresh;
             return snapshot;
         });
@@ -12065,7 +12065,7 @@ function buildNetworkSnapshot$14(context, coercedAdapterRequestContext) {
         modes,
         optionalFields,
     };
-    return buildNetworkSnapshot$15(luvio, recordUiConfig, dispatchOptions).then((snapshot) => processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot, adapterContext, optionalFields));
+    return buildNetworkSnapshot$19(luvio, recordUiConfig, dispatchOptions).then((snapshot) => processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot, adapterContext, optionalFields));
 }
 function buildRecordLayoutCachedSnapshot(context, storeLookup) {
     const { config, luvio } = context;
@@ -12149,7 +12149,7 @@ function makeCacheOnlySnapshot(luvio, config, adapterContext, cachedSnapshot) {
 function makeNetworkOnlySnapshot(luvio, config, adapterContext, requestContext) {
     return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, () => {
         return undefined;
-    }, buildNetworkSnapshot$14);
+    }, buildNetworkSnapshot$18);
 }
 function getRecordLayoutType(luvio, config, adapterContext, requestContext) {
     // lookup record layout
@@ -12186,10 +12186,10 @@ function getRecordLayoutType(luvio, config, adapterContext, requestContext) {
                 if (!fields) {
                     return makeNetworkOnlySnapshot(luvio, config, adapterContext, requestContext);
                 }
-                return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, buildRecordSnapshot(luvio, config, recordLayoutSnapshot, objectInfoSnapshot, fields), buildNetworkSnapshot$14);
+                return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, buildRecordSnapshot(luvio, config, recordLayoutSnapshot, objectInfoSnapshot, fields), buildNetworkSnapshot$18);
             }
             return makeRecordLayoutMap(luvio, config, objectInfoSnapshot.data.apiName, recordTypeId, layoutTypes, modes, adapterContext).then((recordLayoutMap) => {
-                return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, buildRecordLayoutSnapshot(recordLayoutMap, luvio, config, recordLayoutSnapshot, objectInfoSnapshot), buildNetworkSnapshot$14);
+                return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, buildRecordLayoutSnapshot(recordLayoutMap, luvio, config, recordLayoutSnapshot, objectInfoSnapshot), buildNetworkSnapshot$18);
             });
         });
     });
@@ -14068,18 +14068,18 @@ function adapterFragment$J(luvio, config) {
 function onFetchResponseSuccess$M(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$R(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$13(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$17(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$N(luvio, config, resourceParams, response) {
     const snapshot = ingestError$K(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$13(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$17(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$13(luvio, config, options) {
+function buildNetworkSnapshot$17(luvio, config, options) {
     const resourceParams = createResourceParams$_(config);
     const request = createResourceRequest$15(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -14094,7 +14094,7 @@ function buildNetworkSnapshot$13(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$R(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$13, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$17, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$Q(context, storeLookup) {
     const { luvio, config } = context;
@@ -14105,7 +14105,7 @@ function buildCachedSnapshotCachePolicy$Q(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$13(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$17(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -14299,18 +14299,18 @@ function adapterFragment$I(luvio, config) {
 function onFetchResponseSuccess$L(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$Q(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$12(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$16(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$M(luvio, config, resourceParams, response) {
     const snapshot = ingestError$J(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$12(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$16(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$12(luvio, config, options) {
+function buildNetworkSnapshot$16(luvio, config, options) {
     const resourceParams = createResourceParams$Z(config);
     const request = createResourceRequest$14(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -14325,7 +14325,7 @@ function buildNetworkSnapshot$12(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$Q(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$12, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$16, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$P(context, storeLookup) {
     const { luvio, config } = context;
@@ -14336,7 +14336,7 @@ function buildCachedSnapshotCachePolicy$P(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$12(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$16(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -14473,18 +14473,18 @@ function adapterFragment$H(luvio, config) {
 function onFetchResponseSuccess$K(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$P(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$11(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$15(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$L(luvio, config, resourceParams, response) {
     const snapshot = ingestError$I(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$11(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$15(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$11(luvio, config, options) {
+function buildNetworkSnapshot$15(luvio, config, options) {
     const resourceParams = createResourceParams$Y(config);
     const request = createResourceRequest$13(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -14499,7 +14499,7 @@ function buildNetworkSnapshot$11(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$P(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$11, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$15, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$O(context, storeLookup) {
     const { luvio, config } = context;
@@ -14510,7 +14510,7 @@ function buildCachedSnapshotCachePolicy$O(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$11(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$15(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -14615,18 +14615,18 @@ function adapterFragment$G(luvio, config) {
 function onFetchResponseSuccess$J(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$O(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$10(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$14(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$K(luvio, config, resourceParams, response) {
     const snapshot = ingestError$H(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$10(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$14(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$10(luvio, config, options) {
+function buildNetworkSnapshot$14(luvio, config, options) {
     const resourceParams = createResourceParams$X(config);
     const request = createResourceRequest$12(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -14641,7 +14641,7 @@ function buildNetworkSnapshot$10(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$O(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$10, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$14, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$N(context, storeLookup) {
     const { luvio, config } = context;
@@ -14652,7 +14652,7 @@ function buildCachedSnapshotCachePolicy$N(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$10(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$14(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -14804,18 +14804,18 @@ function adapterFragment$F(luvio, config) {
 function onFetchResponseSuccess$I(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$N(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$13(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$J(luvio, config, resourceParams, response) {
     const snapshot = ingestError$G(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$13(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$$(luvio, config, options) {
+function buildNetworkSnapshot$13(luvio, config, options) {
     const resourceParams = createResourceParams$W(config);
     const request = createResourceRequest$11(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -14830,7 +14830,7 @@ function buildNetworkSnapshot$$(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$N(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$$, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$13, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$M(context, storeLookup) {
     const { luvio, config } = context;
@@ -14841,7 +14841,7 @@ function buildCachedSnapshotCachePolicy$M(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$13(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -15068,18 +15068,18 @@ function adapterFragment$E(luvio, config) {
 function onFetchResponseSuccess$H(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$M(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$12(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$I(luvio, config, resourceParams, response) {
     const snapshot = ingestError$F(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$12(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$_(luvio, config, options) {
+function buildNetworkSnapshot$12(luvio, config, options) {
     const resourceParams = createResourceParams$V(config);
     const request = createResourceRequest$10(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -15094,7 +15094,7 @@ function buildNetworkSnapshot$_(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$M(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$_, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$12, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$L(context, storeLookup) {
     const { luvio, config } = context;
@@ -15105,7 +15105,7 @@ function buildCachedSnapshotCachePolicy$L(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$12(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -16278,18 +16278,18 @@ function adapterFragment$D(luvio, config) {
 function onFetchResponseSuccess$G(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$L(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$Z(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$11(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$H(luvio, config, resourceParams, response) {
     const snapshot = ingestError$E(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$Z(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$11(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$Z(luvio, config, options) {
+function buildNetworkSnapshot$11(luvio, config, options) {
     const resourceParams = createResourceParams$U(config);
     const request = createResourceRequest$$(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -16304,7 +16304,7 @@ function buildNetworkSnapshot$Z(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$L(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$Z, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$11, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$K(context, storeLookup) {
     const { luvio, config } = context;
@@ -16315,7 +16315,7 @@ function buildCachedSnapshotCachePolicy$K(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$Z(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$11(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -16456,7 +16456,7 @@ function adapterFragment$C(luvio, config) {
     const resourceParams = createResourceParams$T(config);
     return selectFields$6(luvio, resourceParams);
 }
-function buildNetworkSnapshot$Y(luvio, config, options) {
+function buildNetworkSnapshot$10(luvio, config, options) {
     const resourceParams = createResourceParams$T(config);
     const request = createResourceRequest$_(resourceParams);
     const key = keyBuilder$3b(luvio, config);
@@ -16532,18 +16532,18 @@ function buildCachedSnapshot$6(luvio, config) {
     };
     return luvio.storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$Y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$10(luvio, config, snapshotRefreshOptions)
     });
 }
 function onFetchResponseError$G(luvio, config, resourceParams, response) {
     const snapshot = ingestError$D(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$Y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$10(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function buildNetworkSnapshotCachePolicy$K(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$Y, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$10, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$J(context, storeLookup) {
     const { luvio, config } = context;
@@ -16554,7 +16554,7 @@ function buildCachedSnapshotCachePolicy$J(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$Y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$10(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -16669,18 +16669,18 @@ function adapterFragment$B(luvio, config) {
 function onFetchResponseSuccess$F(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$K(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$X(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$F(luvio, config, resourceParams, response) {
     const snapshot = ingestError$C(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$X(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$X(luvio, config, options) {
+function buildNetworkSnapshot$$(luvio, config, options) {
     const resourceParams = createResourceParams$S(config);
     const request = createResourceRequest$Z(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -16695,7 +16695,7 @@ function buildNetworkSnapshot$X(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$J(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$X, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$$, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$I(context, storeLookup) {
     const { luvio, config } = context;
@@ -16706,7 +16706,7 @@ function buildCachedSnapshotCachePolicy$I(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$X(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -16811,18 +16811,18 @@ function adapterFragment$A(luvio, config) {
 function onFetchResponseSuccess$E(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$J(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$W(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$E(luvio, config, resourceParams, response) {
     const snapshot = ingestError$B(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$W(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$W(luvio, config, options) {
+function buildNetworkSnapshot$_(luvio, config, options) {
     const resourceParams = createResourceParams$R(config);
     const request = createResourceRequest$Y(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -16837,7 +16837,7 @@ function buildNetworkSnapshot$W(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$I(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$W, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$_, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$H(context, storeLookup) {
     const { luvio, config } = context;
@@ -16848,7 +16848,7 @@ function buildCachedSnapshotCachePolicy$H(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$W(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -17318,18 +17318,18 @@ function adapterFragment$z(luvio, config) {
 function onFetchResponseSuccess$D(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$H(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$V(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Z(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$D(luvio, config, resourceParams, response) {
     const snapshot = ingestError$z(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$V(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Z(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$V(luvio, config, options) {
+function buildNetworkSnapshot$Z(luvio, config, options) {
     const resourceParams = createResourceParams$Q(config);
     const request = createResourceRequest$W(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -17344,7 +17344,7 @@ function buildNetworkSnapshot$V(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$H(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$V, 'get', false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$Z, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$G(context, storeLookup) {
     const { luvio, config } = context;
@@ -17355,7 +17355,7 @@ function buildCachedSnapshotCachePolicy$G(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$V(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Z(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -17411,18 +17411,18 @@ function adapterFragment$y(luvio, config) {
 function onFetchResponseSuccess$C(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$I(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$U(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Y(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$C(luvio, config, resourceParams, response) {
     const snapshot = ingestError$A(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$U(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Y(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$U(luvio, config, options) {
+function buildNetworkSnapshot$Y(luvio, config, options) {
     const resourceParams = createResourceParams$P(config);
     const request = createResourceRequest$X(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -17437,7 +17437,7 @@ function buildNetworkSnapshot$U(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$G(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$U, 'get', false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$Y, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$F(context, storeLookup) {
     const { luvio, config } = context;
@@ -17448,7 +17448,7 @@ function buildCachedSnapshotCachePolicy$F(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$U(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Y(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -17554,18 +17554,18 @@ function adapterFragment$x(luvio, config) {
 function onFetchResponseSuccess$B(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$G(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$T(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$X(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$B(luvio, config, resourceParams, response) {
     const snapshot = ingestError$y(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$T(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$X(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$T(luvio, config, options) {
+function buildNetworkSnapshot$X(luvio, config, options) {
     const resourceParams = createResourceParams$O(config);
     const request = createResourceRequest$V(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -17580,7 +17580,7 @@ function buildNetworkSnapshot$T(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$F(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$T, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$X, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$E(context, storeLookup) {
     const { luvio, config } = context;
@@ -17591,7 +17591,7 @@ function buildCachedSnapshotCachePolicy$E(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$T(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$X(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -18808,18 +18808,18 @@ function adapterFragment$w(luvio, config) {
 function onFetchResponseSuccess$A(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$F(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$S(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$W(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$A(luvio, config, resourceParams, response) {
     const snapshot = ingestError$x(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$S(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$W(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$S(luvio, config, options) {
+function buildNetworkSnapshot$W(luvio, config, options) {
     const resourceParams = createResourceParams$N(config);
     const request = createResourceRequest$U(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -18834,7 +18834,7 @@ function buildNetworkSnapshot$S(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$E(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$S, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$W, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$D(context, storeLookup) {
     const { luvio, config } = context;
@@ -18845,7 +18845,7 @@ function buildCachedSnapshotCachePolicy$D(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$S(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$W(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -18947,18 +18947,18 @@ function adapterFragment$v(luvio, config) {
 function onFetchResponseSuccess$z(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$E(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$R(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$V(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$z(luvio, config, resourceParams, response) {
     const snapshot = ingestError$w(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$R(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$V(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$R(luvio, config, options) {
+function buildNetworkSnapshot$V(luvio, config, options) {
     const resourceParams = createResourceParams$M(config);
     const request = createResourceRequest$T(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -18973,7 +18973,7 @@ function buildNetworkSnapshot$R(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$D(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$R, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$V, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$C(context, storeLookup) {
     const { luvio, config } = context;
@@ -18984,7 +18984,7 @@ function buildCachedSnapshotCachePolicy$C(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$R(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$V(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -19090,18 +19090,18 @@ function adapterFragment$u(luvio, config) {
 function onFetchResponseSuccess$y(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$D(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$Q(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$U(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$y(luvio, config, resourceParams, response) {
     const snapshot = ingestError$v(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$Q(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$U(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$Q(luvio, config, options) {
+function buildNetworkSnapshot$U(luvio, config, options) {
     const resourceParams = createResourceParams$L(config);
     const request = createResourceRequest$S(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -19116,7 +19116,7 @@ function buildNetworkSnapshot$Q(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$C(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$Q, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$U, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$B(context, storeLookup) {
     const { luvio, config } = context;
@@ -19127,7 +19127,7 @@ function buildCachedSnapshotCachePolicy$B(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$Q(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$U(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -19691,18 +19691,18 @@ function adapterFragment$t(luvio, config) {
 function onFetchResponseSuccess$x(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$C(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$T(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$x(luvio, config, resourceParams, response) {
     const snapshot = ingestError$u(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$T(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$P(luvio, config, options) {
+function buildNetworkSnapshot$T(luvio, config, options) {
     const resourceParams = createResourceParams$K(config);
     const request = createResourceRequest$R(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -19717,7 +19717,7 @@ function buildNetworkSnapshot$P(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$B(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$P, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$T, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$A(context, storeLookup) {
     const { luvio, config } = context;
@@ -19728,7 +19728,7 @@ function buildCachedSnapshotCachePolicy$A(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$T(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -19804,7 +19804,7 @@ function onFetchResponseSuccess$w(luvio, config, resourceParams, response) {
         variables: {},
     }, {
         config,
-        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$S(luvio, config, snapshotRefreshOptions),
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
@@ -19851,7 +19851,7 @@ function buildCachedSnapshotCachePolicy$z(context, storeLookup) {
     };
     return storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$S(luvio, config, snapshotRefreshOptions),
     });
 }
 
@@ -19885,11 +19885,11 @@ function validateAdapterConfig$P(untrustedConfig, configPropertyNames) {
 function onFetchResponseError$w(luvio, config, resourceParams, response) {
     const snapshot = ingestError$t(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$S(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$O(luvio, config, options) {
+function buildNetworkSnapshot$S(luvio, config, options) {
     const resourceParams = createResourceParams$J(config);
     const request = createResourceRequest$Q(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -19904,7 +19904,7 @@ function buildNetworkSnapshot$O(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$A(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$O, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$S, undefined, false);
 }
 const getLayoutAdapterFactory = (luvio) => function UiApi__getLayout(untrustedConfig, requestContext) {
     const config = validateAdapterConfig$Q(untrustedConfig);
@@ -19948,11 +19948,11 @@ function buildCachedSnapshot$5(luvio, config) {
     };
     return luvio.storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$N(luvio, config),
+        resolve: () => buildNetworkSnapshot$R(luvio, config),
     });
 }
 
-function buildNetworkSnapshot$N(luvio, config, context) {
+function buildNetworkSnapshot$R(luvio, config, context) {
     const { resourceParams, request, key } = prepareRequest$4(luvio, config);
     return luvio
         .dispatchResourceRequest(request, context)
@@ -19983,7 +19983,7 @@ function onFetchResponseSuccess$v(luvio, config, key, response) {
 function onFetchResponseError$v(luvio, config, key, error) {
     const errorSnapshot = luvio.errorSnapshot(error, {
         config,
-        resolve: () => buildNetworkSnapshot$N(luvio, config),
+        resolve: () => buildNetworkSnapshot$R(luvio, config),
     });
     luvio.storeIngestError(key, errorSnapshot);
     return luvio.storeBroadcast().then(() => errorSnapshot);
@@ -20066,7 +20066,7 @@ function buildCachedSnapshotCachePolicy$y(context, storeLookup) {
     };
     return storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$N(luvio, config),
+        resolve: () => buildNetworkSnapshot$R(luvio, config),
     });
 }
 
@@ -20097,7 +20097,7 @@ function validateAdapterConfig$N(untrustedConfig, configPropertyNames) {
     return config;
 }
 function buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$N, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$R, undefined, false);
 }
 const getLayoutUserStateAdapterFactory = (luvio) => function UiApi__getLayoutUserState(untrustedConfig, requestContext) {
     const config = validateAdapterConfig$O(untrustedConfig, getLayoutUserState_ConfigPropertyNames);
@@ -20471,18 +20471,18 @@ function adapterFragment$s(luvio, config) {
 function onFetchResponseSuccess$u(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$A(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Q(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$u(luvio, config, resourceParams, response) {
     const snapshot = ingestError$r(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Q(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$M(luvio, config, options) {
+function buildNetworkSnapshot$Q(luvio, config, options) {
     const resourceParams = createResourceParams$I(config);
     const request = createResourceRequest$N(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -20497,7 +20497,7 @@ function buildNetworkSnapshot$M(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$y(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$M, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$Q, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$x(context, storeLookup) {
     const { luvio, config } = context;
@@ -20508,7 +20508,7 @@ function buildCachedSnapshotCachePolicy$x(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$Q(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -20619,14 +20619,14 @@ function adapterFragment$r(luvio, config) {
 function onFetchResponseSuccess$t(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$z(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$L(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$t(luvio, config, resourceParams, response) {
     const snapshot = ingestError$q(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$L(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
@@ -20705,7 +20705,7 @@ function getPaginationMetadata$2(luvio, resourceParams) {
     }
     return node.data.__metadata;
 }
-function buildNetworkSnapshot$L(luvio, config, options, cacheSnapshot) {
+function buildNetworkSnapshot$P(luvio, config, options, cacheSnapshot) {
     const resourceParams = createResourceParams$H(config);
     const request = prepareRequest$3(luvio, config, resourceParams, cacheSnapshot);
     return luvio.dispatchResourceRequest(request, options)
@@ -20720,7 +20720,7 @@ function buildNetworkSnapshot$L(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$x(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$L, undefined, true);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$P, undefined, true);
 }
 function buildCachedSnapshotCachePolicy$w(context, storeLookup) {
     const { luvio, config } = context;
@@ -20731,7 +20731,7 @@ function buildCachedSnapshotCachePolicy$w(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$L(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$P(luvio, config, snapshotRefreshOptions)
     });
     if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
         context.cacheSnapshot = cacheSnapshot;
@@ -20937,7 +20937,7 @@ function validateAdapterConfig$K(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$K(luvio, config, options) {
+function buildNetworkSnapshot$O(luvio, config, options) {
     const resourceParams = createResourceParams$G(config);
     const request = createResourceRequest$L(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -20962,7 +20962,7 @@ const createListInfoAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "createListInfo"');
         }
-        return buildNetworkSnapshot$K(luvio, config);
+        return buildNetworkSnapshot$O(luvio, config);
     };
 };
 
@@ -21024,7 +21024,7 @@ function validateAdapterConfig$J(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$J(luvio, config, options) {
+function buildNetworkSnapshot$N(luvio, config, options) {
     const resourceParams = createResourceParams$F(config);
     const request = createResourceRequest$K(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -21049,7 +21049,7 @@ const deleteListInfoAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error(`Invalid config for "${adapterName$B}"`);
         }
-        return buildNetworkSnapshot$J(luvio, config);
+        return buildNetworkSnapshot$N(luvio, config);
     };
 };
 
@@ -21089,18 +21089,18 @@ function adapterFragment$q(luvio, config) {
 function onFetchResponseSuccess$s(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$B(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$I(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$s(luvio, config, resourceParams, response) {
     const snapshot = ingestError$s(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$I(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$I(luvio, config, options) {
+function buildNetworkSnapshot$M(luvio, config, options) {
     const resourceParams = createResourceParams$E(config);
     const request = createResourceRequest$O(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -21115,7 +21115,7 @@ function buildNetworkSnapshot$I(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$w(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$I, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$M, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$v(context, storeLookup) {
     const { luvio, config } = context;
@@ -21126,7 +21126,7 @@ function buildCachedSnapshotCachePolicy$v(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$I(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$M(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -21227,7 +21227,7 @@ function validateAdapterConfig$H(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$H(luvio, config, options) {
+function buildNetworkSnapshot$L(luvio, config, options) {
     const resourceParams = createResourceParams$D(config);
     const request = createResourceRequest$J(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -21252,7 +21252,7 @@ const updateListInfoByNameAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "updateListInfoByName"');
         }
-        return buildNetworkSnapshot$H(luvio, config);
+        return buildNetworkSnapshot$L(luvio, config);
     };
 };
 
@@ -22159,18 +22159,18 @@ function adapterFragment$p(luvio, config) {
 function onFetchResponseSuccess$r(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$w(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$G(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$K(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$r(luvio, config, resourceParams, response) {
     const snapshot = ingestError$p(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$G(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$K(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$G(luvio, config, options) {
+function buildNetworkSnapshot$K(luvio, config, options) {
     const resourceParams = createResourceParams$C(config);
     const request = createResourceRequest$I(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -22185,7 +22185,7 @@ function buildNetworkSnapshot$G(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$v(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$G, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$K, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$u(context, storeLookup) {
     const { luvio, config } = context;
@@ -22196,7 +22196,7 @@ function buildCachedSnapshotCachePolicy$u(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$G(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$K(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -22469,18 +22469,18 @@ function adapterFragment$o(luvio, config) {
 function onFetchResponseSuccess$q(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$v(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$F(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$J(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$q(luvio, config, resourceParams, response) {
     const snapshot = ingestError$o(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$F(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$J(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$F(luvio, config, options) {
+function buildNetworkSnapshot$J(luvio, config, options) {
     const resourceParams = createResourceParams$B(config);
     const request = createResourceRequest$H(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -22495,7 +22495,7 @@ function buildNetworkSnapshot$F(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$u(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$F, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$J, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$t(context, storeLookup) {
     const { luvio, config } = context;
@@ -22506,7 +22506,7 @@ function buildCachedSnapshotCachePolicy$t(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$F(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$J(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -22651,7 +22651,7 @@ function validateAdapterConfig$E(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$E(luvio, config, options) {
+function buildNetworkSnapshot$I(luvio, config, options) {
     const resourceParams = createResourceParams$A(config);
     const request = createResourceRequest$G(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -22676,7 +22676,7 @@ const updateListPreferencesAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "updateListPreferences"');
         }
-        return buildNetworkSnapshot$E(luvio, config);
+        return buildNetworkSnapshot$I(luvio, config);
     };
 };
 
@@ -22925,18 +22925,18 @@ function adapterFragment$n(luvio, config) {
 function onFetchResponseSuccess$p(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$t(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$D(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$H(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$p(luvio, config, resourceParams, response) {
     const snapshot = ingestError$n(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$D(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$H(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$D(luvio, config, options) {
+function buildNetworkSnapshot$H(luvio, config, options) {
     const resourceParams = createResourceParams$z(config);
     const request = createResourceRequest$F(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -22951,7 +22951,7 @@ function buildNetworkSnapshot$D(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$t(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$D, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$H, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$s(context, storeLookup) {
     const { luvio, config } = context;
@@ -22962,7 +22962,7 @@ function buildCachedSnapshotCachePolicy$s(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$D(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$H(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -23054,18 +23054,18 @@ function adapterFragment$m(luvio, config) {
 function onFetchResponseSuccess$o(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$s(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$G(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$o(luvio, config, resourceParams, response) {
     const snapshot = ingestError$m(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$G(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$C(luvio, config, options) {
+function buildNetworkSnapshot$G(luvio, config, options) {
     const resourceParams = createResourceParams$y(config);
     const request = createResourceRequest$E();
     return luvio.dispatchResourceRequest(request, options)
@@ -23080,7 +23080,7 @@ function buildNetworkSnapshot$C(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$C, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$G, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$r(context, storeLookup) {
     const { luvio, config } = context;
@@ -23091,7 +23091,7 @@ function buildCachedSnapshotCachePolicy$r(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$G(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -23403,18 +23403,18 @@ function adapterFragment$l(luvio, config) {
 function onFetchResponseSuccess$n(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$r(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$F(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$n(luvio, config, resourceParams, response) {
     const snapshot = ingestError$l(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$F(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$B(luvio, config, options) {
+function buildNetworkSnapshot$F(luvio, config, options) {
     const resourceParams = createResourceParams$x(config);
     const request = createResourceRequest$D(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -23429,7 +23429,7 @@ function buildNetworkSnapshot$B(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$r(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$B, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$F, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$q(context, storeLookup) {
     const { luvio, config } = context;
@@ -23440,7 +23440,7 @@ function buildCachedSnapshotCachePolicy$q(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$F(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -24044,18 +24044,18 @@ function adapterFragment$k(luvio, config) {
 function onFetchResponseSuccess$m(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$q(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$E(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$m(luvio, config, resourceParams, response) {
     const snapshot = ingestError$k(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$E(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$A(luvio, config, options) {
+function buildNetworkSnapshot$E(luvio, config, options) {
     const resourceParams = createResourceParams$w(config);
     const request = createResourceRequest$C(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -24070,7 +24070,7 @@ function buildNetworkSnapshot$A(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$q(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$A, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$E, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$p(context, storeLookup) {
     const { luvio, config } = context;
@@ -24081,7 +24081,7 @@ function buildCachedSnapshotCachePolicy$p(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$E(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -24116,7 +24116,7 @@ const path = select$2t().selections;
 function buildSnapshotRefresh$2(luvio, config) {
     return {
         config,
-        resolve: () => buildNetworkSnapshot$z(luvio, config),
+        resolve: () => buildNetworkSnapshot$D(luvio, config),
     };
 }
 function buildRequestAndKey(luvio, config) {
@@ -24144,7 +24144,7 @@ function onResponseError(luvio, config, key, err) {
     luvio.storeIngestError(key, errorSnapshot);
     return luvio.storeBroadcast().then(() => errorSnapshot);
 }
-function buildNetworkSnapshot$z(luvio, config, options) {
+function buildNetworkSnapshot$D(luvio, config, options) {
     const { resourceParams, request, key } = buildRequestAndKey(luvio, config);
     return luvio.dispatchResourceRequest(request, options).then((response) => {
         return luvio.handleSuccessResponse(() => {
@@ -24196,7 +24196,7 @@ function buildNetworkSnapshotCachePolicy$p(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$z(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$D(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$o(context, storeLookup) {
     const { config, luvio } = context;
@@ -24370,18 +24370,18 @@ function adapterFragment$j(luvio, config) {
 function onFetchResponseSuccess$l(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$p(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$l(luvio, config, resourceParams, response) {
     const snapshot = ingestError$j(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$y(luvio, config, options) {
+function buildNetworkSnapshot$C(luvio, config, options) {
     const resourceParams = createResourceParams$v(config);
     const request = createResourceRequest$A(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -24396,7 +24396,7 @@ function buildNetworkSnapshot$y(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$o(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$C, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$n(context, storeLookup) {
     const { luvio, config } = context;
@@ -24407,7 +24407,7 @@ function buildCachedSnapshotCachePolicy$n(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$C(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -24737,18 +24737,18 @@ function adapterFragment$i(luvio, config) {
 function onFetchResponseSuccess$k(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$o(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$k(luvio, config, resourceParams, response) {
     const snapshot = ingestError$i(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$x(luvio, config, options) {
+function buildNetworkSnapshot$B(luvio, config, options) {
     const resourceParams = createResourceParams$u(config);
     const request = createResourceRequest$z(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -24763,7 +24763,7 @@ function buildNetworkSnapshot$x(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$n(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, 'get', false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$B, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$m(context, storeLookup) {
     const { luvio, config } = context;
@@ -24774,7 +24774,7 @@ function buildCachedSnapshotCachePolicy$m(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$B(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -25916,7 +25916,7 @@ function buildCachedSnapshot$3(luvio, config) {
     const { recordIds } = config;
     return luvio.storeLookup(recordAvatarsSelector(recordIds), {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions),
     });
 }
 
@@ -25971,7 +25971,7 @@ function ingestFakeResponse(luvio, recordIds) {
 function isRecordAvatarBulkMapRepresentation(response) {
     return response.body.hasErrors === undefined;
 }
-function buildNetworkSnapshot$w(luvio, config, options) {
+function buildNetworkSnapshot$A(luvio, config, options) {
     const { uncachedRecordIds, recordIds } = config;
     const { recordIdsInFlight, recordIdsNotInFlight } = getRecordIdsFlightStatus(uncachedRecordIds || recordIds, // If uncached records were specified, only get those, otherwise, get all of them
     IN_FLIGHT_REQUESTS);
@@ -26045,7 +26045,7 @@ function buildCachedSnapshotCachePolicy$l(context, storeLookup) {
     const { recordIds } = config;
     const cachedSnapshot = storeLookup(recordAvatarsSelector(recordIds), {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions),
     });
     // if the L1 lookup had some data but not all, then put the cache keys that were
     // missing onto the context, so buildNetworkSnapshotCachePolicy only requests
@@ -26074,7 +26074,7 @@ function buildNetworkSnapshotCachePolicy$m(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$w(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$A(luvio, config, dispatchOptions);
 }
 
 const adapterName$p = 'getRecordAvatars';
@@ -26106,14 +26106,14 @@ function validateAdapterConfig$v(untrustedConfig, configPropertyNames) {
 function onFetchResponseSuccess$j(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$n(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$j(luvio, config, resourceParams, response) {
     const snapshot = ingestError$h(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$A(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
@@ -26282,11 +26282,11 @@ function keyBuilder$2p(luvio, config) {
 function onFetchResponseError$i(luvio, config, resourceParams, response) {
     const snapshot = ingestError$Q(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$v(luvio, config, options) {
+function buildNetworkSnapshot$z(luvio, config, options) {
     const resourceParams = createResourceParams$14(config);
     const request = createResourceRequest$1f(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -26301,7 +26301,7 @@ function buildNetworkSnapshot$v(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$v, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$z, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$k(context, storeLookup) {
     const { luvio, config } = context;
@@ -26312,7 +26312,7 @@ function buildCachedSnapshotCachePolicy$k(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$z(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -27054,18 +27054,18 @@ function adapterFragment$h(luvio, config) {
 function onFetchResponseSuccess$i(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$l(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$h(luvio, config, resourceParams, response) {
     const snapshot = ingestError$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$u(luvio, config, options) {
+function buildNetworkSnapshot$y(luvio, config, options) {
     const resourceParams = createResourceParams$s(config);
     const request = createResourceRequest$w(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -27080,7 +27080,7 @@ function buildNetworkSnapshot$u(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$k(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$j(context, storeLookup) {
     const { luvio, config } = context;
@@ -27091,7 +27091,7 @@ function buildCachedSnapshotCachePolicy$j(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$y(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -27143,18 +27143,18 @@ function adapterFragment$g(luvio, config) {
 function onFetchResponseSuccess$h(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$m(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$g(luvio, config, resourceParams, response) {
     const snapshot = ingestError$g(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$t(luvio, config, options) {
+function buildNetworkSnapshot$x(luvio, config, options) {
     const resourceParams = createResourceParams$r(config);
     const request = createResourceRequest$x(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -27169,7 +27169,7 @@ function buildNetworkSnapshot$t(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$j(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$t, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
     const { luvio, config } = context;
@@ -27180,7 +27180,7 @@ function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$t(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$x(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -28018,18 +28018,18 @@ function adapterFragment$f(luvio, config) {
 function onFetchResponseSuccess$g(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$j(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$f(luvio, config, resourceParams, response) {
     const snapshot = ingestError$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$s(luvio, config, options) {
+function buildNetworkSnapshot$w(luvio, config, options) {
     const resourceParams = createResourceParams$q(config);
     const request = createResourceRequest$u(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -28044,7 +28044,7 @@ function buildNetworkSnapshot$s(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$s, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$w, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
@@ -28055,7 +28055,7 @@ function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$w(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -28411,18 +28411,18 @@ function adapterFragment$e(luvio, config) {
 function onFetchResponseSuccess$f(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$i(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$e(luvio, config, resourceParams, response) {
     const snapshot = ingestError$c(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$r(luvio, config, options) {
+function buildNetworkSnapshot$v(luvio, config, options) {
     const resourceParams = createResourceParams$p(config);
     const request = createResourceRequest$t(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -28437,7 +28437,7 @@ function buildNetworkSnapshot$r(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$r, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$v, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
@@ -28448,7 +28448,7 @@ function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$v(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -28503,18 +28503,18 @@ function adapterFragment$d(luvio, config) {
 function onFetchResponseSuccess$e(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$k(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$q(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$d(luvio, config, resourceParams, response) {
     const snapshot = ingestError$e(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$q(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$q(luvio, config, options) {
+function buildNetworkSnapshot$u(luvio, config, options) {
     const resourceParams = createResourceParams$o(config);
     const request = createResourceRequest$v(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -28529,7 +28529,7 @@ function buildNetworkSnapshot$q(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$q, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
@@ -28540,7 +28540,7 @@ function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$q(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$u(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -28678,7 +28678,7 @@ function validateAdapterConfig$o(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$p(luvio, config, options) {
+function buildNetworkSnapshot$t(luvio, config, options) {
     const resourceParams = createResourceParams$n(config);
     const request = createResourceRequest$s(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -28703,7 +28703,7 @@ const updateRelatedListInfoAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "updateRelatedListInfo"');
         }
-        return buildNetworkSnapshot$p(luvio, config);
+        return buildNetworkSnapshot$t(luvio, config);
     };
 };
 
@@ -29165,18 +29165,18 @@ function adapterFragment$c(luvio, config) {
 function onFetchResponseSuccess$d(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$f(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$c(luvio, config, resourceParams, response) {
     const snapshot = ingestError$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$o(luvio, config, options) {
+function buildNetworkSnapshot$s(luvio, config, options) {
     const resourceParams = createResourceParams$m(config);
     const request = createResourceRequest$q(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -29191,7 +29191,7 @@ function buildNetworkSnapshot$o(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$s, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
@@ -29202,7 +29202,7 @@ function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$s(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -29251,18 +29251,18 @@ function adapterFragment$b(luvio, config) {
 function onFetchResponseSuccess$c(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$g(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$b(luvio, config, resourceParams, response) {
     const snapshot = ingestError$b(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$n(luvio, config, options) {
+function buildNetworkSnapshot$r(luvio, config, options) {
     const resourceParams = createResourceParams$l(config);
     const request = createResourceRequest$r(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -29277,7 +29277,7 @@ function buildNetworkSnapshot$n(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$r, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
@@ -29288,7 +29288,7 @@ function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$r(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -29412,7 +29412,7 @@ function validateAdapterConfig$l(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$m(luvio, config, options) {
+function buildNetworkSnapshot$q(luvio, config, options) {
     const resourceParams = createResourceParams$k(config);
     const request = createResourceRequest$p(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -29437,7 +29437,7 @@ const updateRelatedListPreferencesAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "updateRelatedListPreferences"');
         }
-        return buildNetworkSnapshot$m(luvio, config);
+        return buildNetworkSnapshot$q(luvio, config);
     };
 };
 
@@ -30737,18 +30737,18 @@ function adapterFragment$a(luvio, config) {
 function onFetchResponseSuccess$b(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$c(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$a(luvio, config, resourceParams, response) {
     const snapshot = ingestError$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$l(luvio, config, options) {
+function buildNetworkSnapshot$p(luvio, config, options) {
     const resourceParams = createResourceParams$j(config);
     const request = createResourceRequest$n(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -30763,7 +30763,7 @@ function buildNetworkSnapshot$l(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, 'get', false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$p, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     const { luvio, config } = context;
@@ -30774,7 +30774,7 @@ function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$p(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -30832,14 +30832,14 @@ function adapterFragment$9(luvio, config) {
 function onFetchResponseSuccess$a(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$d(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$9(luvio, config, resourceParams, response) {
     const snapshot = ingestError$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
@@ -30910,7 +30910,7 @@ function getPaginationMetadata$1(luvio, resourceParams) {
     }
     return node.data.__metadata;
 }
-function buildNetworkSnapshot$k(luvio, config, options, cacheSnapshot) {
+function buildNetworkSnapshot$o(luvio, config, options, cacheSnapshot) {
     const resourceParams = createResourceParams$i(config);
     const request = prepareRequest$2(luvio, config, resourceParams, cacheSnapshot);
     return luvio.dispatchResourceRequest(request, options)
@@ -30925,7 +30925,7 @@ function buildNetworkSnapshot$k(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, 'get', true);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, 'get', true);
 }
 function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
@@ -30936,7 +30936,7 @@ function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$o(luvio, config, snapshotRefreshOptions)
     });
     if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
         context.cacheSnapshot = cacheSnapshot;
@@ -31268,18 +31268,18 @@ function adapterFragment$8(luvio, config) {
 function onFetchResponseSuccess$9(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$b(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$8(luvio, config, resourceParams, response) {
     const snapshot = ingestError$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$j(luvio, config, options) {
+function buildNetworkSnapshot$n(luvio, config, options) {
     const resourceParams = createResourceParams$h(config);
     const request = createResourceRequest$m(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -31294,7 +31294,7 @@ function buildNetworkSnapshot$j(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
@@ -31305,7 +31305,7 @@ function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$n(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -31524,18 +31524,18 @@ function adapterFragment$7(luvio, config) {
 function onFetchResponseSuccess$8(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$a(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$7(luvio, config, resourceParams, response) {
     const snapshot = ingestError$6(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$i(luvio, config, options) {
+function buildNetworkSnapshot$m(luvio, config, options) {
     const resourceParams = createResourceParams$g(config);
     const request = createResourceRequest$l(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -31550,7 +31550,7 @@ function buildNetworkSnapshot$i(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$i, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$m, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
@@ -31561,7 +31561,7 @@ function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$m(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -31941,18 +31941,18 @@ function adapterFragment$6(luvio, config) {
 function onFetchResponseSuccess$7(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$9(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$6(luvio, config, resourceParams, response) {
     const snapshot = ingestError$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$h(luvio, config, options) {
+function buildNetworkSnapshot$l(luvio, config, options) {
     const resourceParams = createResourceParams$f(config);
     const request = createResourceRequest$k(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -31967,7 +31967,7 @@ function buildNetworkSnapshot$h(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$h, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -31978,7 +31978,7 @@ function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$h(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$l(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -32971,18 +32971,18 @@ function adapterFragment$5(luvio, config) {
 function onFetchResponseSuccess$6(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$8(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$5(luvio, config, resourceParams, response) {
     const snapshot = ingestError$4(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$g(luvio, config, options) {
+function buildNetworkSnapshot$k(luvio, config, options) {
     const resourceParams = createResourceParams$e(config);
     const request = createResourceRequest$j(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -32997,7 +32997,7 @@ function buildNetworkSnapshot$g(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$g, 'get', false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -33008,7 +33008,7 @@ function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$k(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -33254,18 +33254,18 @@ function adapterFragment$4(luvio, config) {
 function onFetchResponseSuccess$5(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$7(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$4(luvio, config, resourceParams, response) {
     const snapshot = ingestError$3(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$f(luvio, config, options) {
+function buildNetworkSnapshot$j(luvio, config, options) {
     const resourceParams = createResourceParams$d(config);
     const request = createResourceRequest$i(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -33280,7 +33280,7 @@ function buildNetworkSnapshot$f(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, 'get', false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -33291,7 +33291,7 @@ function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$f(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$j(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -60697,18 +60697,18 @@ function adapterFragment$3(luvio, config) {
 function onFetchResponseSuccess$4(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$5(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions),
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$3(luvio, config, resourceParams, response) {
     const snapshot = ingestError$1(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions),
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$e(luvio, config, options) {
+function buildNetworkSnapshot$i(luvio, config, options) {
     const resourceParams = createResourceParams$c(transformConfiguration$1(config));
     const request = createResourceRequest$f(resourceParams);
     return luvio.dispatchResourceRequest(request, options).then((response) => {
@@ -60737,7 +60737,7 @@ function buildNetworkSnapshotCachePolicy$6(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$e(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$i(luvio, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     const { luvio, config } = context;
@@ -60748,7 +60748,7 @@ function buildCachedSnapshotCachePolicy$5(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$e(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$i(luvio, config, snapshotRefreshOptions),
     });
     return cacheSnapshot;
 }
@@ -60870,6 +60870,25 @@ function createResourceRequest$e(config) {
     };
 }
 
+/**
+ * Builds the dispatch options for a DML (mutating) adapter from the caller's
+ * narrowed request context, forwarding the `requestCorrelator` so the
+ * originating observability context reaches the network adapter.
+ *
+ * Returns `undefined` when no request context was supplied, preserving the
+ * pre-existing behavior where mutating adapters dispatched with no options.
+ */
+function createDispatchResourceRequestContext$2(requestContext) {
+    if (requestContext === undefined) {
+        return undefined;
+    }
+    return {
+        resourceRequestContext: {
+            requestCorrelator: requestContext.requestCorrelator,
+        },
+    };
+}
+
 const adapterName$8 = 'executeBatchRecordOperations';
 const executeBatchRecordOperations_ConfigPropertyMetadata = [
     generateParamConfigMetadata('allOrNone', true, 2, 1, false),
@@ -60932,7 +60951,7 @@ function validateAdapterConfig$c(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$d(luvio, config, options) {
+function buildNetworkSnapshot$h(luvio, config, options) {
     const resourceParams = batchUpdateRecordsCreateResourceParams(config);
     const request = createResourceRequest$e(resourceParams);
     return luvio.dispatchResourceRequest(request, options).then((response) => {
@@ -60950,14 +60969,14 @@ function buildNetworkSnapshot$d(luvio, config, options) {
     });
 }
 const factory$f = (luvio) => {
-    return function executeBatchRecordOperations(untrustedConfig) {
+    return function executeBatchRecordOperations(untrustedConfig, requestContext) {
         const config = validateAdapterConfig$c(untrustedConfig, executeBatchRecordOperations_ConfigPropertyNames);
         // Invalid or incomplete config
         if (config === null) {
             // eslint-disable-next-line @salesforce/lds/no-error-in-production
             throw new Error('Invalid config for "executeBatchRecordOperations"');
         }
-        return buildNetworkSnapshot$d(luvio, config);
+        return buildNetworkSnapshot$h(luvio, config, createDispatchResourceRequestContext$2(requestContext));
     };
 };
 
@@ -61030,18 +61049,18 @@ function adapterFragment$2(luvio, config) {
 function onFetchResponseSuccess$3(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$6(luvio, config, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$2(luvio, config, resourceParams, response) {
     const snapshot = ingestError$2(luvio, config, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$c(luvio, config, options) {
+function buildNetworkSnapshot$g(luvio, config, options) {
     const resourceParams = createResourceParams$b(transformConfiguration(config));
     const request = createResourceRequest$g(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -61065,7 +61084,7 @@ function buildNetworkSnapshot$c(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$g, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -61076,7 +61095,7 @@ function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$c(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$g(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -61153,7 +61172,7 @@ const performUpdateRecordQuickAction_ConfigPropertyMetadata = [
     generateParamConfigMetadata('fields', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createResourceParams$a = /*#__PURE__*/ createResourceParams$16(performUpdateRecordQuickAction_ConfigPropertyMetadata);
-function buildNetworkSnapshot$b(luvio, config, options) {
+function buildNetworkSnapshot$f(luvio, config, options) {
     const resourceParams = createResourceParams$a(config);
     const request = createResourceRequest$d(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -61217,7 +61236,7 @@ const performQuickAction_ConfigPropertyMetadata = [
     generateParamConfigMetadata('fields', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createResourceParams$9 = /*#__PURE__*/ createResourceParams$16(performQuickAction_ConfigPropertyMetadata);
-function buildNetworkSnapshot$a(luvio, config, options) {
+function buildNetworkSnapshot$e(luvio, config, options) {
     const resourceParams = createResourceParams$9(config);
     const request = createResourceRequest$c(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -61236,31 +61255,37 @@ function buildNetworkSnapshot$a(luvio, config, options) {
     });
 }
 
+function buildNetworkSnapshot$d(luvio, config, options) {
+    return buildNetworkSnapshot$f(luvio, config, options);
+}
 const factory$d = (luvio) => {
-    return function (untrustedConfig) {
+    return function (untrustedConfig, requestContext) {
         const config = untrustedConfig;
         const draftAdapter = configurationForRestAdapters.getDraftAwarePerformUpdateRecordQuickActionAdapter();
         if (draftAdapter !== undefined) {
             return draftAdapter(config, (config) => {
                 const resourceParams = createResourceParams$9(config);
                 return createResourceRequest$d(resourceParams);
-            });
+            }, requestContext);
         }
-        return buildNetworkSnapshot$b(luvio, config);
+        return buildNetworkSnapshot$d(luvio, config, createDispatchResourceRequestContext$2(requestContext));
     };
 };
 
+function buildNetworkSnapshot$c(luvio, config, options) {
+    return buildNetworkSnapshot$e(luvio, config, options);
+}
 const factory$c = (luvio) => {
-    return function (untrustedConfig) {
+    return function (untrustedConfig, requestContext) {
         const config = untrustedConfig;
         const draftAdapter = configurationForRestAdapters.getDraftAwarePerformQuickActionAdapter();
         if (draftAdapter !== undefined) {
             return draftAdapter(config, (config) => {
                 const resourceParams = createResourceParams$9(config);
                 return createResourceRequest$c(resourceParams);
-            });
+            }, requestContext);
         }
-        return buildNetworkSnapshot$a(luvio, config);
+        return buildNetworkSnapshot$c(luvio, config, createDispatchResourceRequestContext$2(requestContext));
     };
 };
 
@@ -61309,8 +61334,10 @@ function addAdditionalFieldsForNorming(layoutUserState, apiName, recordTypeId, l
     layoutUserState.layoutType = layoutType;
     layoutUserState.mode = mode;
 }
-function updateLayoutUserState(luvio, config, key, updateRequest) {
-    return luvio.dispatchResourceRequest(updateRequest).then((response) => {
+function updateLayoutUserState(luvio, config, key, updateRequest, options) {
+    return luvio
+        .dispatchResourceRequest(updateRequest, options)
+        .then((response) => {
         const { body } = response;
         return luvio.handleSuccessResponse(() => ingestAndBroadcast(luvio, key, config, body), () => {
             const cache = new StoreKeyMap();
@@ -61387,7 +61414,7 @@ function coerceConfigWithDefaults$2(untrusted, layoutUserStateInput) {
     };
 }
 const factory$b = (luvio) => {
-    return (untrustedObjectApiName, untrustedRecordTypeId, untrustedLayoutType, untrustedMode, untrustedLayoutUserStateInput) => {
+    return (untrustedObjectApiName, untrustedRecordTypeId, untrustedLayoutType, untrustedMode, untrustedLayoutUserStateInput, requestContext) => {
         const untrusted = {
             objectApiName: untrustedObjectApiName,
             recordTypeId: untrustedRecordTypeId,
@@ -61427,11 +61454,11 @@ const factory$b = (luvio) => {
                 ingestAndBroadcast(luvio, key, config, updatedLayoutUserState);
             }
         }
-        return updateLayoutUserState(luvio, config, key, updateRequest);
+        return updateLayoutUserState(luvio, config, key, updateRequest, createDispatchResourceRequestContext$2(requestContext));
     };
 };
 
-function buildNetworkSnapshot$9(luvio, config, options, cacheSnapshot) {
+function buildNetworkSnapshot$b(luvio, config, options, cacheSnapshot) {
     const resourceParams = createResourceParams$8(config);
     const request = prepareRequest$1(luvio, config, resourceParams, cacheSnapshot);
     return luvio.dispatchResourceRequest(request, options).then((response) => {
@@ -61503,14 +61530,14 @@ function adapterFragment$1(luvio, config) {
 function onFetchResponseSuccess$2(luvio, config, resourceParams, response) {
     const snapshot = ingestSuccess$U(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
 function onFetchResponseError$1(luvio, config, resourceParams, response) {
     const snapshot = ingestError$N(luvio, resourceParams, response, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
@@ -61590,7 +61617,7 @@ function getPaginationMetadata(luvio, resourceParams) {
     return node.data.__metadata;
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, 'get', true);
+    return buildNetworkSnapshotCachePolicy$X(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, 'get', true);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -61601,7 +61628,7 @@ function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$9(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$b(luvio, config, snapshotRefreshOptions)
     });
     if (isUnfulfilledSnapshot$1(cacheSnapshot) && cacheSnapshot.data !== undefined) {
         context.cacheSnapshot = cacheSnapshot;
@@ -61903,7 +61930,7 @@ function removeEtags(recordRep) {
         }
     });
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
+function buildNetworkSnapshot$a(luvio, config, options) {
     const { objectApiName, fieldApiName } = config;
     const resourceParams = {
         /*
@@ -61981,7 +62008,7 @@ function buildNetworkSnapshotCachePolicy$3(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$8(context.luvio, context.config, dispatchOptions);
+    return buildNetworkSnapshot$a(context.luvio, context.config, dispatchOptions);
 }
 const factory$9 = (luvio) => {
     return (untrustedConfig, requestContext) => {
@@ -61991,7 +62018,7 @@ const factory$9 = (luvio) => {
         }
         const refresh = {
             config,
-            resolve: () => buildNetworkSnapshot$8(luvio, config),
+            resolve: () => buildNetworkSnapshot$a(luvio, config),
         };
         const promiseOrSnapshot = luvio.applyCachePolicy(requestContext || {}, { config, luvio }, buildCachedSnapshot$2, buildNetworkSnapshotCachePolicy$3);
         if (isPromise(promiseOrSnapshot)) {
@@ -62048,8 +62075,44 @@ function validateAdapterConfig$7(untrustedConfig, configPropertyNames) {
     return config;
 }
 
+function buildNetworkSnapshot$9(luvio, resourceParams, options) {
+    const request = createResourceRequest$9(resourceParams);
+    return luvio.dispatchResourceRequest(request, options).then((response) => {
+        const { body } = response;
+        const key = keyBuilderFromType$f(luvio, body);
+        return luvio.handleSuccessResponse(() => {
+            let selectors;
+            if (body.type === 'Theme') {
+                selectors = select$2l;
+                luvio.storeIngest(key, ingest$22, body);
+            }
+            else if (body.type === 'Photo') {
+                selectors = select$2m;
+                luvio.storeIngest(key, ingest$23, body);
+            }
+            else {
+                // eslint-disable-next-line @salesforce/lds/no-error-in-production
+                throw new Error('Unsupported avatar type');
+            }
+            // TODO [W-6804405]: support unions on fragments (only supported on links today)
+            const snapshot = luvio.storeLookup({
+                recordId: key,
+                node: selectors(),
+                variables: {},
+            });
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
+            const cache = new StoreKeyMap();
+            getTypeCacheKeys$24(cache, luvio, body);
+            return cache;
+        });
+    }, (err) => {
+        deepFreeze(err);
+        throw err;
+    });
+}
 const factory$8 = (luvio) => {
-    return (untrustedConfig) => {
+    return (untrustedConfig, requestContext) => {
         const config = validateAdapterConfig$7(untrustedConfig, updateRecordAvatar_ConfigPropertyNames);
         if (config === null) {
             // eslint-disable-next-line @salesforce/lds/no-error-in-production
@@ -62067,40 +62130,7 @@ const factory$8 = (luvio) => {
                 actionType: config.actionType,
             },
         };
-        const request = createResourceRequest$9(resourceParams);
-        return luvio.dispatchResourceRequest(request).then((response) => {
-            const { body } = response;
-            const key = keyBuilderFromType$f(luvio, body);
-            return luvio.handleSuccessResponse(() => {
-                let selectors;
-                if (body.type === 'Theme') {
-                    selectors = select$2l;
-                    luvio.storeIngest(key, ingest$22, body);
-                }
-                else if (body.type === 'Photo') {
-                    selectors = select$2m;
-                    luvio.storeIngest(key, ingest$23, body);
-                }
-                else {
-                    // eslint-disable-next-line @salesforce/lds/no-error-in-production
-                    throw new Error('Unsupported avatar type');
-                }
-                // TODO [W-6804405]: support unions on fragments (only supported on links today)
-                const snapshot = luvio.storeLookup({
-                    recordId: key,
-                    node: selectors(),
-                    variables: {},
-                });
-                return luvio.storeBroadcast().then(() => snapshot);
-            }, () => {
-                const cache = new StoreKeyMap();
-                getTypeCacheKeys$24(cache, luvio, body);
-                return cache;
-            });
-        }, (err) => {
-            deepFreeze(err);
-            throw err;
-        });
+        return buildNetworkSnapshot$9(luvio, resourceParams, createDispatchResourceRequestContext$2(requestContext));
     };
 };
 
@@ -62690,10 +62720,10 @@ function buildSelector(resp) {
 function buildSnapshotRefresh$1(luvio, context, config) {
     return {
         config,
-        resolve: () => buildNetworkSnapshot$7(luvio, context, config),
+        resolve: () => buildNetworkSnapshot$8(luvio, context, config),
     };
 }
-function buildNetworkSnapshot$7(luvio, context, config, options) {
+function buildNetworkSnapshot$8(luvio, context, config, options) {
     const params = createResourceParams$7(config);
     const request = createResourceRequest$8(params);
     const key = keyBuilder$7(luvio, params);
@@ -62777,7 +62807,7 @@ function buildNetworkSnapshotCachePolicy$2(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$7(luvio, adapterContext, config, dispatchOptions);
+    return buildNetworkSnapshot$8(luvio, adapterContext, config, dispatchOptions);
 }
 const factory$7 = (luvio) => {
     return luvio.withContext(function UiApi__getRecordCreateDefaults(untrusted, adapterContext, requestContext) {
@@ -63321,7 +63351,7 @@ function getRecordTypeId$1(adapterConfig, context) {
     }
     return contextValue;
 }
-const buildNetworkSnapshot$6 = (luvio, context, config, options) => {
+const buildNetworkSnapshot$7 = (luvio, context, config, options) => {
     const resourceParams = createResourceParams$6(config);
     const recordTypeId = getRecordTypeId$1(config, context);
     const { recordId } = config;
@@ -63384,7 +63414,7 @@ const buildNetworkSnapshot$6 = (luvio, context, config, options) => {
             });
             const errorSnapshot = luvio.errorSnapshot(response, {
                 config,
-                resolve: () => buildNetworkSnapshot$6(luvio, context, config, snapshotRefreshOptions),
+                resolve: () => buildNetworkSnapshot$7(luvio, context, config, snapshotRefreshOptions),
             });
             luvio.storeIngestError(key, errorSnapshot, RECORD_TEMPLATE_CLONE_ERROR_STORE_METADATA_PARAMS);
             return Promise.resolve(errorSnapshot);
@@ -63404,7 +63434,7 @@ const buildCachedSnapshot$1 = (luvio, context, config) => {
     };
     return luvio.storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, context, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$7(luvio, context, config, snapshotRefreshOptions),
     });
 };
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
@@ -63422,7 +63452,7 @@ function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$6(luvio, adapterContext, config, dispatchOptions);
+    return buildNetworkSnapshot$7(luvio, adapterContext, config, dispatchOptions);
 }
 function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     const { adapterContext, config, luvio, recordTypeId } = context;
@@ -63442,7 +63472,7 @@ function buildCachedSnapshotCachePolicy$1(context, storeLookup) {
     };
     return storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$6(luvio, adapterContext, updatedConfig, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$7(luvio, adapterContext, updatedConfig, snapshotRefreshOptions),
     });
 }
 const factory$6 = (luvio) => luvio.withContext(function getRecordTemplateClone_ContextWrapper(untrustedConfig, adapterContext, requestContext) {
@@ -63937,7 +63967,7 @@ const contextId = `${keyPrefix}__${adapterName$2}`;
 function buildSnapshotRefresh(luvio, context, config) {
     return {
         config,
-        resolve: () => buildNetworkSnapshot$5(luvio, context, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$6(luvio, context, config, snapshotRefreshOptions),
     };
 }
 function buildRecordTypeIdContextKey(objectApiName) {
@@ -64018,7 +64048,7 @@ function onFetchResponseError(luvio, context, config, resourceParams, error) {
     const snapshot = ingestError(luvio, resourceParams, error, buildSnapshotRefresh(luvio, context, config));
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$5(luvio, context, config, options) {
+function buildNetworkSnapshot$6(luvio, context, config, options) {
     const resourceParams = createResourceParams$5(config);
     const request = prepareRequest(luvio, context, config);
     return luvio
@@ -64061,7 +64091,7 @@ const buildNetworkSnapshotCachePolicy = (context, coercedAdapterRequestContext)
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$5(luvio, adapterContext, config, dispatchOptions);
+    return buildNetworkSnapshot$6(luvio, adapterContext, config, dispatchOptions);
 };
 const buildCachedSnapshotCachePolicy = (context, storeLookup) => {
     const { adapterContext, config, luvio, recordTypeId } = context;
@@ -64150,7 +64180,7 @@ function onResponseSuccess(luvio, response, recordIngest, conflictMap) {
     });
     return luvio.storeBroadcast().then(() => snapshot);
 }
-function buildNetworkSnapshot$4(luvio, config) {
+function buildNetworkSnapshot$5(luvio, config, options) {
     const resourceParams = createResourceParams$4(config);
     const request = createResourceRequest$5(resourceParams);
     const fieldTrie = BLANK_RECORD_FIELDS_TRIE;
@@ -64160,7 +64190,7 @@ function buildNetworkSnapshot$4(luvio, config) {
         serverRequestCount: 1,
     };
     const recordIngest = createRecordIngest(fieldTrie, optionalFieldTrie, conflictMap);
-    return luvio.dispatchResourceRequest(request).then((response) => {
+    return luvio.dispatchResourceRequest(request, options).then((response) => {
         return luvio.handleSuccessResponse(() => onResponseSuccess(luvio, response, recordIngest, conflictMap), () => {
             const cache = new StoreKeyMap();
             getResponseCacheKeys$3(cache, luvio, resourceParams, response.body);
@@ -64176,13 +64206,13 @@ function createResourceRequest$4(config) {
     return createResourceRequest$5(resourceParams);
 }
 const factory$4 = (luvio) => {
-    return function (untrustedConfig) {
+    return function (untrustedConfig, requestContext) {
         const config = untrustedConfig;
         const draftAdapter = configurationForRestAdapters.getDraftAwareCreateRecordAdapter();
         if (draftAdapter !== undefined) {
-            return draftAdapter(config, createResourceRequest$4);
+            return draftAdapter(config, createResourceRequest$4, requestContext);
         }
-        return buildNetworkSnapshot$4(luvio, config);
+        return buildNetworkSnapshot$5(luvio, config, createDispatchResourceRequestContext$2(requestContext));
     };
 };
 
@@ -64242,7 +64272,7 @@ function validateAdapterConfig$3(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function buildNetworkSnapshot$3(luvio, config, options) {
+function buildNetworkSnapshot$4(luvio, config, options) {
     const resourceParams = createResourceParams$3(config);
     const request = createResourceRequest$3(resourceParams);
     return luvio.dispatchResourceRequest(request, options)
@@ -64260,29 +64290,26 @@ function buildNetworkSnapshot$3(luvio, config, options) {
         throw response;
     });
 }
-const deleteRecordAdapterFactory = (luvio) => {
-    return function UiApideleteRecord(untrustedConfig) {
-        const config = validateAdapterConfig$3(untrustedConfig, deleteRecord_ConfigPropertyNames);
-        // Invalid or incomplete config
-        if (config === null) {
-            throw new Error(`Invalid config for "${adapterName$1}"`);
-        }
-        return buildNetworkSnapshot$3(luvio, config);
-    };
-};
 
+function buildNetworkSnapshot$3(luvio, config, options) {
+    return buildNetworkSnapshot$4(luvio, config, options);
+}
 const factory$3 = (luvio) => {
-    const deleteRecordAdapterInstance = deleteRecordAdapterFactory(luvio);
-    return (recordId) => {
+    return (recordId, requestContext) => {
         const config = { recordId };
         const draftAdapter = configurationForRestAdapters.getDraftAwareDeleteRecordAdapter();
         if (draftAdapter !== undefined) {
             return draftAdapter(config, (config) => {
                 const params = createResourceParams$3(config);
                 return createResourceRequest$3(params);
-            });
+            }, requestContext);
+        }
+        const validatedConfig = validateAdapterConfig$3(config, deleteRecord_ConfigPropertyNames);
+        if (validatedConfig === null) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error('Invalid config for "deleteRecord"');
         }
-        return deleteRecordAdapterInstance(config);
+        return buildNetworkSnapshot$3(luvio, validatedConfig, createDispatchResourceRequestContext$2(requestContext));
     };
 };