@salesforce/lwc-adapters-uiapi 1.444.0 → 1.445.0

package/dist/main.js

@@ -11357,7 +11357,7 @@ function mergeAndRefreshLowerVersionRecord(luvio, incoming, existing, incomingTr
             };
         }
         else {
-            buildNetworkSnapshot$1b(luvio, {
+            buildNetworkSnapshot$1f(luvio, {
                 recordId: incoming.id,
                 optionalFields: convertTrieToFields(incomingTrackedFieldsTrieRoot),
             });
@@ -11841,7 +11841,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) {
@@ -11886,7 +11886,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
@@ -11943,7 +11943,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);
@@ -12306,7 +12306,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: {},
     };
@@ -12316,11 +12316,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) => {
@@ -12347,7 +12347,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) => {
@@ -12359,7 +12359,7 @@ function resolveConflict(luvio, map) {
             return acc;
         }, []);
         const config = { records };
-        buildNetworkSnapshot$1a(luvio, config, map.serverRequestCount);
+        buildNetworkSnapshot$1e(luvio, config, map.serverRequestCount);
     }
 }
 
@@ -15316,14 +15316,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);
 }
@@ -15402,7 +15402,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)
@@ -15417,7 +15417,7 @@ function buildNetworkSnapshot$17(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$T(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$17, undefined, true);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$1b, undefined, true);
 }
 function buildCachedSnapshotCachePolicy$S(context, storeLookup) {
     const { luvio, config } = context;
@@ -15428,7 +15428,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;
@@ -17360,18 +17360,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)
@@ -17386,7 +17386,7 @@ function buildNetworkSnapshot$16(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$S(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$16, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$1a, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$R(context, storeLookup) {
     const { luvio, config } = context;
@@ -17397,7 +17397,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;
 }
@@ -18683,7 +18683,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) {
@@ -18837,7 +18837,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)
@@ -18905,7 +18905,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);
@@ -18972,7 +18972,7 @@ function refresh$1(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 });
@@ -19128,7 +19128,7 @@ function getRecord$1(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();
@@ -19154,7 +19154,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;
         });
@@ -19167,7 +19167,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;
@@ -19251,7 +19251,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
@@ -19288,10 +19288,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);
             });
         });
     });
@@ -20858,18 +20858,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)
@@ -20884,7 +20884,7 @@ function buildNetworkSnapshot$13(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$R(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$13, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$17, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$Q(context, storeLookup) {
     const { luvio, config } = context;
@@ -20895,7 +20895,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;
 }
@@ -21089,18 +21089,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)
@@ -21115,7 +21115,7 @@ function buildNetworkSnapshot$12(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$Q(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$12, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$16, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$P(context, storeLookup) {
     const { luvio, config } = context;
@@ -21126,7 +21126,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;
 }
@@ -21263,18 +21263,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)
@@ -21289,7 +21289,7 @@ function buildNetworkSnapshot$11(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$P(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$11, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$15, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$O(context, storeLookup) {
     const { luvio, config } = context;
@@ -21300,7 +21300,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;
 }
@@ -21405,18 +21405,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)
@@ -21431,7 +21431,7 @@ function buildNetworkSnapshot$10(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$O(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$10, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$14, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$N(context, storeLookup) {
     const { luvio, config } = context;
@@ -21442,7 +21442,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;
 }
@@ -21594,18 +21594,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)
@@ -21620,7 +21620,7 @@ function buildNetworkSnapshot$$(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$N(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$$, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$13, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$M(context, storeLookup) {
     const { luvio, config } = context;
@@ -21631,7 +21631,7 @@ function buildCachedSnapshotCachePolicy$M(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$13(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -21858,18 +21858,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)
@@ -21884,7 +21884,7 @@ function buildNetworkSnapshot$_(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$M(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$_, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$12, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$L(context, storeLookup) {
     const { luvio, config } = context;
@@ -21895,7 +21895,7 @@ function buildCachedSnapshotCachePolicy$L(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$12(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -23068,18 +23068,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)
@@ -23094,7 +23094,7 @@ function buildNetworkSnapshot$Z(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$L(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$Z, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$11, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$K(context, storeLookup) {
     const { luvio, config } = context;
@@ -23105,7 +23105,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;
 }
@@ -23246,7 +23246,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);
@@ -23322,18 +23322,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$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$Y, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$10, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$J(context, storeLookup) {
     const { luvio, config } = context;
@@ -23344,7 +23344,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;
 }
@@ -23459,18 +23459,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)
@@ -23485,7 +23485,7 @@ function buildNetworkSnapshot$X(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$J(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$X, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$$, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$I(context, storeLookup) {
     const { luvio, config } = context;
@@ -23496,7 +23496,7 @@ function buildCachedSnapshotCachePolicy$I(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$X(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$$(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -23601,18 +23601,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)
@@ -23627,7 +23627,7 @@ function buildNetworkSnapshot$W(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$I(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$W, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$_, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$H(context, storeLookup) {
     const { luvio, config } = context;
@@ -23638,7 +23638,7 @@ function buildCachedSnapshotCachePolicy$H(context, storeLookup) {
     };
     const cacheSnapshot = storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$W(luvio, config, snapshotRefreshOptions)
+        resolve: () => buildNetworkSnapshot$_(luvio, config, snapshotRefreshOptions)
     });
     return cacheSnapshot;
 }
@@ -24108,18 +24108,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)
@@ -24134,7 +24134,7 @@ function buildNetworkSnapshot$V(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$H(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$V, 'get', false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$Z, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$G(context, storeLookup) {
     const { luvio, config } = context;
@@ -24145,7 +24145,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;
 }
@@ -24201,18 +24201,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)
@@ -24227,7 +24227,7 @@ function buildNetworkSnapshot$U(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$G(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$U, 'get', false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$Y, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$F(context, storeLookup) {
     const { luvio, config } = context;
@@ -24238,7 +24238,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;
 }
@@ -24344,18 +24344,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)
@@ -24370,7 +24370,7 @@ function buildNetworkSnapshot$T(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$F(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$T, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$X, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$E(context, storeLookup) {
     const { luvio, config } = context;
@@ -24381,7 +24381,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;
 }
@@ -25598,18 +25598,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)
@@ -25624,7 +25624,7 @@ function buildNetworkSnapshot$S(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$E(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$S, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$W, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$D(context, storeLookup) {
     const { luvio, config } = context;
@@ -25635,7 +25635,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;
 }
@@ -25741,18 +25741,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)
@@ -25767,7 +25767,7 @@ function buildNetworkSnapshot$Q(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$C(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$Q, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$U, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$B(context, storeLookup) {
     const { luvio, config } = context;
@@ -25778,7 +25778,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;
 }
@@ -26342,18 +26342,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)
@@ -26368,7 +26368,7 @@ function buildNetworkSnapshot$P(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$B(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$P, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$T, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$A(context, storeLookup) {
     const { luvio, config } = context;
@@ -26379,7 +26379,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;
 }
@@ -26455,7 +26455,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);
 }
@@ -26502,7 +26502,7 @@ function buildCachedSnapshotCachePolicy$z(context, storeLookup) {
     };
     return storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$O(luvio, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$S(luvio, config, snapshotRefreshOptions),
     });
 }
 
@@ -26536,11 +26536,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)
@@ -26555,7 +26555,7 @@ function buildNetworkSnapshot$O(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$A(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$O, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$S, undefined, false);
 }
 const getLayoutAdapterFactory = (luvio) => function UiApi__getLayout(untrustedConfig, requestContext) {
     const config = validateAdapterConfig$Q(untrustedConfig);
@@ -26599,11 +26599,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)
@@ -26634,7 +26634,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);
@@ -26717,7 +26717,7 @@ function buildCachedSnapshotCachePolicy$y(context, storeLookup) {
     };
     return storeLookup(selector, {
         config,
-        resolve: () => buildNetworkSnapshot$N(luvio, config),
+        resolve: () => buildNetworkSnapshot$R(luvio, config),
     });
 }
 
@@ -26748,7 +26748,7 @@ function validateAdapterConfig$N(untrustedConfig, configPropertyNames) {
     return config;
 }
 function buildNetworkSnapshotCachePolicy$z(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$N, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$R, undefined, false);
 }
 const getLayoutUserStateAdapterFactory = (luvio) => function UiApi__getLayoutUserState(untrustedConfig, requestContext) {
     const config = validateAdapterConfig$O(untrustedConfig, getLayoutUserState_ConfigPropertyNames);
@@ -27122,18 +27122,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)
@@ -27148,7 +27148,7 @@ function buildNetworkSnapshot$M(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$y(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$M, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$Q, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$x(context, storeLookup) {
     const { luvio, config } = context;
@@ -27159,7 +27159,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;
 }
@@ -27270,14 +27270,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);
 }
@@ -27356,7 +27356,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)
@@ -27371,7 +27371,7 @@ function buildNetworkSnapshot$L(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$x(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$L, undefined, true);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$P, undefined, true);
 }
 function buildCachedSnapshotCachePolicy$w(context, storeLookup) {
     const { luvio, config } = context;
@@ -27382,7 +27382,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;
@@ -27588,7 +27588,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)
@@ -27613,7 +27613,7 @@ const createListInfoAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "createListInfo"');
         }
-        return buildNetworkSnapshot$K(luvio, config);
+        return buildNetworkSnapshot$O(luvio, config);
     };
 };
 
@@ -27675,7 +27675,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)
@@ -27700,7 +27700,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);
     };
 };
 
@@ -27740,18 +27740,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)
@@ -27766,7 +27766,7 @@ function buildNetworkSnapshot$I(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$w(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$I, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$M, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$v(context, storeLookup) {
     const { luvio, config } = context;
@@ -27777,7 +27777,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;
 }
@@ -27878,7 +27878,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)
@@ -27903,7 +27903,7 @@ const updateListInfoByNameAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "updateListInfoByName"');
         }
-        return buildNetworkSnapshot$H(luvio, config);
+        return buildNetworkSnapshot$L(luvio, config);
     };
 };
 
@@ -28810,18 +28810,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)
@@ -28836,7 +28836,7 @@ function buildNetworkSnapshot$G(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$v(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$G, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$K, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$u(context, storeLookup) {
     const { luvio, config } = context;
@@ -28847,7 +28847,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;
 }
@@ -29120,18 +29120,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)
@@ -29146,7 +29146,7 @@ function buildNetworkSnapshot$F(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$u(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$F, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$J, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$t(context, storeLookup) {
     const { luvio, config } = context;
@@ -29157,7 +29157,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;
 }
@@ -29302,7 +29302,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)
@@ -29327,7 +29327,7 @@ const updateListPreferencesAdapterFactory = (luvio) => {
         if (config === null) {
             throw new Error('Invalid config for "updateListPreferences"');
         }
-        return buildNetworkSnapshot$E(luvio, config);
+        return buildNetworkSnapshot$I(luvio, config);
     };
 };
 
@@ -29576,18 +29576,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)
@@ -29602,7 +29602,7 @@ function buildNetworkSnapshot$D(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$t(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$D, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$H, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$s(context, storeLookup) {
     const { luvio, config } = context;
@@ -29613,7 +29613,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;
 }
@@ -29925,18 +29925,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)
@@ -29951,7 +29951,7 @@ function buildNetworkSnapshot$B(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$r(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$B, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$F, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$q(context, storeLookup) {
     const { luvio, config } = context;
@@ -29962,7 +29962,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;
 }
@@ -30566,18 +30566,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)
@@ -30592,7 +30592,7 @@ function buildNetworkSnapshot$A(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$q(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$A, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$E, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$p(context, storeLookup) {
     const { luvio, config } = context;
@@ -30603,7 +30603,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;
 }
@@ -30638,7 +30638,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) {
@@ -30666,7 +30666,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(() => {
@@ -30718,7 +30718,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;
@@ -30892,18 +30892,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)
@@ -30918,7 +30918,7 @@ function buildNetworkSnapshot$y(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$o(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$C, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$n(context, storeLookup) {
     const { luvio, config } = context;
@@ -30929,7 +30929,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;
 }
@@ -31259,18 +31259,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)
@@ -31285,7 +31285,7 @@ function buildNetworkSnapshot$x(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$n(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, 'get', false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$B, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$m(context, storeLookup) {
     const { luvio, config } = context;
@@ -31296,7 +31296,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;
 }
@@ -32438,7 +32438,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),
     });
 }
 
@@ -32493,7 +32493,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);
@@ -32567,7 +32567,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
@@ -32596,7 +32596,7 @@ function buildNetworkSnapshotCachePolicy$m(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$w(luvio, config, dispatchOptions);
+    return buildNetworkSnapshot$A(luvio, config, dispatchOptions);
 }
 
 const adapterName$p = 'getRecordAvatars';
@@ -32628,14 +32628,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);
 }
@@ -32804,11 +32804,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)
@@ -32823,7 +32823,7 @@ function buildNetworkSnapshot$v(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$l(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$v, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$z, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$k(context, storeLookup) {
     const { luvio, config } = context;
@@ -32834,7 +32834,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;
 }
@@ -33576,18 +33576,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)
@@ -33602,7 +33602,7 @@ function buildNetworkSnapshot$u(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$k(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$y, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$j(context, storeLookup) {
     const { luvio, config } = context;
@@ -33613,7 +33613,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;
 }
@@ -33665,18 +33665,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)
@@ -33691,7 +33691,7 @@ function buildNetworkSnapshot$t(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$j(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$t, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$x, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$i(context, storeLookup) {
     const { luvio, config } = context;
@@ -33702,7 +33702,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;
 }
@@ -34540,18 +34540,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)
@@ -34566,7 +34566,7 @@ function buildNetworkSnapshot$s(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$i(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$s, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$w, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$h(context, storeLookup) {
     const { luvio, config } = context;
@@ -34577,7 +34577,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;
 }
@@ -34933,18 +34933,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)
@@ -34959,7 +34959,7 @@ function buildNetworkSnapshot$r(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$h(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$r, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$v, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$g(context, storeLookup) {
     const { luvio, config } = context;
@@ -34970,7 +34970,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;
 }
@@ -35025,18 +35025,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)
@@ -35051,7 +35051,7 @@ function buildNetworkSnapshot$q(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$g(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$q, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$u, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$f(context, storeLookup) {
     const { luvio, config } = context;
@@ -35062,7 +35062,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;
 }
@@ -35534,18 +35534,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)
@@ -35560,7 +35560,7 @@ function buildNetworkSnapshot$o(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$f(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$s, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$e(context, storeLookup) {
     const { luvio, config } = context;
@@ -35571,7 +35571,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;
 }
@@ -35620,18 +35620,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)
@@ -35646,7 +35646,7 @@ function buildNetworkSnapshot$n(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$e(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$r, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$d(context, storeLookup) {
     const { luvio, config } = context;
@@ -35657,7 +35657,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;
 }
@@ -36967,18 +36967,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)
@@ -36993,7 +36993,7 @@ function buildNetworkSnapshot$l(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$d(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, 'get', false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$p, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$c(context, storeLookup) {
     const { luvio, config } = context;
@@ -37004,7 +37004,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;
 }
@@ -37062,14 +37062,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);
 }
@@ -37140,7 +37140,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)
@@ -37155,7 +37155,7 @@ function buildNetworkSnapshot$k(luvio, config, options, cacheSnapshot) {
     });
 }
 function buildNetworkSnapshotCachePolicy$c(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, 'get', true);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$o, 'get', true);
 }
 function buildCachedSnapshotCachePolicy$b(context, storeLookup) {
     const { luvio, config } = context;
@@ -37166,7 +37166,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;
@@ -37498,18 +37498,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)
@@ -37524,7 +37524,7 @@ function buildNetworkSnapshot$j(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$b(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$n, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$a(context, storeLookup) {
     const { luvio, config } = context;
@@ -37535,7 +37535,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;
 }
@@ -37754,18 +37754,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)
@@ -37780,7 +37780,7 @@ function buildNetworkSnapshot$i(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$a(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$i, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$m, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$9(context, storeLookup) {
     const { luvio, config } = context;
@@ -37791,7 +37791,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;
 }
@@ -38171,18 +38171,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)
@@ -38197,7 +38197,7 @@ function buildNetworkSnapshot$h(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$9(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$h, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$l, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$8(context, storeLookup) {
     const { luvio, config } = context;
@@ -38208,7 +38208,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;
 }
@@ -39201,18 +39201,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)
@@ -39227,7 +39227,7 @@ function buildNetworkSnapshot$g(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$8(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$g, 'get', false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$k, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$7(context, storeLookup) {
     const { luvio, config } = context;
@@ -39238,7 +39238,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;
 }
@@ -39484,18 +39484,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)
@@ -39510,7 +39510,7 @@ function buildNetworkSnapshot$f(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$7(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$f, 'get', false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$j, 'get', false);
 }
 function buildCachedSnapshotCachePolicy$6(context, storeLookup) {
     const { luvio, config } = context;
@@ -39521,7 +39521,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;
 }
@@ -66927,18 +66927,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) => {
@@ -66967,7 +66967,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;
@@ -66978,7 +66978,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;
 }
@@ -67100,6 +67100,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),
@@ -67162,7 +67181,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) => {
@@ -67180,14 +67199,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));
     };
 };
 
@@ -67260,18 +67279,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)
@@ -67295,7 +67314,7 @@ function buildNetworkSnapshot$c(luvio, config, options) {
     });
 }
 function buildNetworkSnapshotCachePolicy$5(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$c, undefined, false);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$g, undefined, false);
 }
 function buildCachedSnapshotCachePolicy$4(context, storeLookup) {
     const { luvio, config } = context;
@@ -67306,7 +67325,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;
 }
@@ -67383,7 +67402,7 @@ const performUpdateRecordQuickAction_ConfigPropertyMetadata = [
     generateParamConfigMetadata('fields', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createResourceParams$a = /*#__PURE__*/ createResourceParams$k(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)
@@ -67447,7 +67466,7 @@ const performQuickAction_ConfigPropertyMetadata = [
     generateParamConfigMetadata('fields', true, 2 /* Body */, 4 /* Unsupported */),
 ];
 const createResourceParams$9 = /*#__PURE__*/ createResourceParams$k(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)
@@ -67466,35 +67485,41 @@ 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));
     };
 };
 
-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) => {
@@ -67566,14 +67591,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);
 }
@@ -67653,7 +67678,7 @@ function getPaginationMetadata(luvio, resourceParams) {
     return node.data.__metadata;
 }
 function buildNetworkSnapshotCachePolicy$4(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$9, 'get', true);
+    return buildNetworkSnapshotCachePolicy$s(context, coercedAdapterRequestContext, buildNetworkSnapshot$b, 'get', true);
 }
 function buildCachedSnapshotCachePolicy$3(context, storeLookup) {
     const { luvio, config } = context;
@@ -67664,7 +67689,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;
@@ -67966,7 +67991,7 @@ function removeEtags(recordRep) {
         }
     });
 }
-function buildNetworkSnapshot$8(luvio, config, options) {
+function buildNetworkSnapshot$a(luvio, config, options) {
     const { objectApiName, fieldApiName } = config;
     const resourceParams = {
         /*
@@ -68044,7 +68069,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) => {
@@ -68054,7 +68079,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)) {
@@ -68111,8 +68136,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
@@ -68130,40 +68191,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));
     };
 };
 
@@ -68753,10 +68781,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);
@@ -68840,7 +68868,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) {
@@ -69384,7 +69412,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;
@@ -69447,7 +69475,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);
@@ -69467,7 +69495,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) {
@@ -69485,7 +69513,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;
@@ -69505,7 +69533,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) {
@@ -70000,7 +70028,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) {
@@ -70081,7 +70109,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
@@ -70124,7 +70152,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;
@@ -70213,7 +70241,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;
@@ -70223,7 +70251,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);
@@ -70239,13 +70267,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));
     };
 };
 
@@ -70305,7 +70333,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)
@@ -70323,29 +70351,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));
     };
 };