@luvio/environments 0.62.3 → 0.63.2

package/dist/es/es2018/environments.js

@@ -17,6 +17,13 @@ const DefaultDurableSegment = 'DEFAULT';
 const { keys, create, assign, freeze } = Object;
 const { isArray } = Array;
 
+function appendTTLStrategy(storeLookup, ttlStrategy) {
+    return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+}
+function buildNetworkSnapshot(args) {
+    const { buildNetworkSnapshot, buildSnapshotContext } = args;
+    return buildNetworkSnapshot(buildSnapshotContext).then((snapshot) => snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot);
+}
 function buildTTLStrategy(staleDurationMilliseconds = 0) {
     return (timestamp, metadata, valueIsError) => {
         if (metadata !== undefined) {
@@ -34,15 +41,12 @@ function buildTTLStrategy(staleDurationMilliseconds = 0) {
         }
         return StoreResolveResultState.Found;
     };
-}
-function appendTTLStrategy(storeLookup, ttlStrategy) {
-    return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
 }
 
 function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const { buildInMemorySnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, storeLookup } = args;
         const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
         const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
@@ -50,10 +54,16 @@ function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
             // data found in L1 cache
             if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                 // kick off network request, do not await it
-                buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                buildNetworkSnapshot$1(buildSnapshotContext);
                 // return the cached snapshot to caller
                 return snapshot;
             }
+            // network request outstanding
+            if (snapshot.state === 'Pending') {
+                // kick off another network request, do not await it
+                buildNetworkSnapshot$1(buildSnapshotContext);
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // stale data found in L1 cache
             if (snapshot.state === 'Stale') {
                 // kick off network request, do not await it
@@ -71,11 +81,15 @@ function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
                     if (revivedSnapshot.state === 'Fulfilled' ||
                         revivedSnapshot.state === 'Error') {
                         // kick off network request, do not await it
-                        buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        buildNetworkSnapshot$1(buildSnapshotContext);
                         // return the L2 cached snapshot to caller
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        // kick off network request, do not await it
+                        buildNetworkSnapshot$1(buildSnapshotContext);
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // stale data found in L2 cache
                     if (revivedSnapshot.state === 'Stale') {
                         // kick off network request, do not await it
@@ -85,19 +99,18 @@ function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
                         return revivedSnapshot;
                     }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
-            if (snapshot.state === 'Pending') ;
         }
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        return buildNetworkSnapshot(args);
     };
 }
 
 function buildCacheThenNetworkImplementation(funcs) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
         const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
         if (snapshot !== undefined) {
@@ -105,7 +118,9 @@ function buildCacheThenNetworkImplementation(funcs) {
             if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                 return snapshot;
             }
-            if (snapshot.state === 'Pending') ;
+            if (snapshot.state === 'Pending') {
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // data not found in L1 cache, try L2 cache
             return funcs
                 .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -115,24 +130,22 @@ function buildCacheThenNetworkImplementation(funcs) {
                     revivedSnapshot.state === 'Error') {
                     return revivedSnapshot;
                 }
-                if (revivedSnapshot.state === 'Pending') ;
+                if (revivedSnapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(revivedSnapshot);
+                }
                 // data not found in L2 cache, go to the network
-                return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                return buildNetworkSnapshot(args);
             });
         }
         // L1 lookup could not find enough information to even construct a snapshot, go to the network
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        return buildNetworkSnapshot(args);
     };
 }
 
 function buildNoCacheImplementation(funcs) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest } = args;
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then((snapshot) => {
-            if (snapshot.state === 'Pending') ;
-            return snapshot;
-        });
+        return buildNetworkSnapshot(args);
     };
 }
 
@@ -169,6 +182,8 @@ function buildNotCachedErrorSnapshot() {
         error,
         state: 'Error',
         data: undefined,
+        // TODO[@W-10164067]: copy refresh data from the snapshot returned by buildInMemorySnapshot (if any)
+        // refresh: ...
     };
 }
 function buildOnlyIfCachedImplementation(funcs) {
@@ -206,7 +221,7 @@ function buildOnlyIfCachedImplementation(funcs) {
 function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
         const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
         if (snapshot !== undefined) {
@@ -214,11 +229,13 @@ function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
             if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                 return snapshot;
             }
-            if (snapshot.state === 'Pending') ;
+            if (snapshot.state === 'Pending') {
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // stale data found in L1 cache
             if (snapshot.state === 'Stale') {
-                // offline environment is already doing this; uncomment once we get rid of offline environment
-                // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                // buildNetworkSnapshot(args);
                 return snapshot;
             }
             // data not found in L1 cache, try L2 cache
@@ -230,19 +247,21 @@ function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
                     revivedSnapshot.state === 'Error') {
                     return revivedSnapshot;
                 }
-                if (revivedSnapshot.state === 'Pending') ;
+                if (revivedSnapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(revivedSnapshot);
+                }
                 // stale data found in L2 cache
                 if (revivedSnapshot.state === 'Stale') {
-                    // offline environment is already doing this; uncomment once we get rid of offline environment
-                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(args);
                     return revivedSnapshot;
                 }
                 // data not found in L2 cache, go to the network
-                return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                return buildNetworkSnapshot(args);
             });
         }
         // L1 lookup could not find enough information to even construct a snapshot, go to the network
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        return buildNetworkSnapshot(args);
     };
 }
 
@@ -780,7 +799,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         if (ingestStagingStore === null) {
             ingestStagingStore = new Store();
         }
-        return environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+        environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
     };
     const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
         validateNotDisposed();
@@ -973,14 +992,15 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
         validateNotDisposed();
         const cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
+        const resolvePendingSnapshot = (snapshot) => environment.resolvePendingSnapshot(snapshot);
         const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
         const applyCachePolicy = () => {
             return cachePolicyImpl({
                 buildInMemorySnapshot,
                 buildNetworkSnapshot,
                 buildSnapshotContext,
+                resolvePendingSnapshot,
                 storeLookup,
-                dispatchResourceRequest: environment.dispatchResourceRequest,
             });
         };
         return isRevivingTTLOverrides !== undefined

package/dist/es/es2018/makeDurable/cachepolicies/cache-and-network.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/cache-then-network.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/no-cache.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/only-if-cached.d.ts

@@ -1,3 +1,3 @@
-import { CachePolicyImplementationArgs, ErrorSnapshot, Snapshot } from '@luvio/engine';
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/stale-while-revalidate.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/utils.d.ts

@@ -3,5 +3,6 @@ export declare type DurableCachePolicyFunctions = {
     validateNotDisposed: () => void;
     reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
 };
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];
+export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
+export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;

package/dist/es/es2018/utils/language.d.ts

@@ -14,6 +14,6 @@ declare const keys: {
     <T_1 extends Function>(f: T_1): T_1;
     <T_2>(o: T_2): Readonly<T_2>;
 };
-declare const hasOwnProperty: (v: string | number | symbol) => boolean;
+declare const hasOwnProperty: (v: PropertyKey) => boolean;
 declare const isArray: (arg: any) => arg is any[];
 export { create as ObjectCreate, keys as ObjectKeys, assign as ObjectAssign, freeze as ObjectFreeze, hasOwnProperty as ObjectPrototypeHasOwnProperty, isArray as ArrayIsArray, };

package/dist/umd/es2018/environments.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
     typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
-    (global = global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
-}(this, (function (exports, engine) { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
+})(this, (function (exports, engine) { 'use strict';
 
     function isDeprecatedDurableStoreEntry(durableRecord) {
         if (durableRecord.expiration !== undefined) {
@@ -11,6 +11,7 @@
         // Add more deprecated shape checks here
         return false;
     }
+    exports.DurableStoreOperationType = void 0;
     (function (DurableStoreOperationType) {
         DurableStoreOperationType["SetEntries"] = "setEntries";
         DurableStoreOperationType["EvictEntries"] = "evictEntries";
@@ -20,6 +21,13 @@
     const { keys, create, assign, freeze } = Object;
     const { isArray } = Array;
 
+    function appendTTLStrategy(storeLookup, ttlStrategy) {
+        return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+    }
+    function buildNetworkSnapshot(args) {
+        const { buildNetworkSnapshot, buildSnapshotContext } = args;
+        return buildNetworkSnapshot(buildSnapshotContext).then((snapshot) => snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot);
+    }
     function buildTTLStrategy(staleDurationMilliseconds = 0) {
         return (timestamp, metadata, valueIsError) => {
             if (metadata !== undefined) {
@@ -37,15 +45,12 @@
             }
             return engine.StoreResolveResultState.Found;
         };
-    }
-    function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
     }
 
     function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const { buildInMemorySnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, storeLookup } = args;
             const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
@@ -53,10 +58,16 @@
                 // data found in L1 cache
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     // kick off network request, do not await it
-                    buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    buildNetworkSnapshot$1(buildSnapshotContext);
                     // return the cached snapshot to caller
                     return snapshot;
                 }
+                // network request outstanding
+                if (snapshot.state === 'Pending') {
+                    // kick off another network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext);
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
                     // kick off network request, do not await it
@@ -74,11 +85,15 @@
                         if (revivedSnapshot.state === 'Fulfilled' ||
                             revivedSnapshot.state === 'Error') {
                             // kick off network request, do not await it
-                            buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            buildNetworkSnapshot$1(buildSnapshotContext);
                             // return the L2 cached snapshot to caller
                             return revivedSnapshot;
                         }
-                        if (revivedSnapshot.state === 'Pending') ;
+                        if (revivedSnapshot.state === 'Pending') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext);
+                            return args.resolvePendingSnapshot(revivedSnapshot);
+                        }
                         // stale data found in L2 cache
                         if (revivedSnapshot.state === 'Stale') {
                             // kick off network request, do not await it
@@ -88,19 +103,18 @@
                             return revivedSnapshot;
                         }
                         // data not found in L2 cache, go to the network
-                        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        return buildNetworkSnapshot(args);
                     });
                 }
-                if (snapshot.state === 'Pending') ;
             }
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildCacheThenNetworkImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -108,7 +122,9 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // data not found in L1 cache, try L2 cache
                 return funcs
                     .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -118,24 +134,22 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildNoCacheImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest } = args;
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then((snapshot) => {
-                if (snapshot.state === 'Pending') ;
-                return snapshot;
-            });
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -172,6 +186,8 @@
             error,
             state: 'Error',
             data: undefined,
+            // TODO[@W-10164067]: copy refresh data from the snapshot returned by buildInMemorySnapshot (if any)
+            // refresh: ...
         };
     }
     function buildOnlyIfCachedImplementation(funcs) {
@@ -209,7 +225,7 @@
     function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -217,11 +233,13 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
-                    // offline environment is already doing this; uncomment once we get rid of offline environment
-                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(args);
                     return snapshot;
                 }
                 // data not found in L1 cache, try L2 cache
@@ -233,19 +251,21 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // stale data found in L2 cache
                     if (revivedSnapshot.state === 'Stale') {
-                        // offline environment is already doing this; uncomment once we get rid of offline environment
-                        // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                        // buildNetworkSnapshot(args);
                         return revivedSnapshot;
                     }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -783,7 +803,7 @@
             if (ingestStagingStore === null) {
                 ingestStagingStore = new engine.Store();
             }
-            return environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
         };
         const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
             validateNotDisposed();
@@ -976,14 +996,15 @@
         const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             const cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
+            const resolvePendingSnapshot = (snapshot) => environment.resolvePendingSnapshot(snapshot);
             const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
             const applyCachePolicy = () => {
                 return cachePolicyImpl({
                     buildInMemorySnapshot,
                     buildNetworkSnapshot,
                     buildSnapshotContext,
+                    resolvePendingSnapshot,
                     storeLookup,
-                    dispatchResourceRequest: environment.dispatchResourceRequest,
                 });
             };
             return isRevivingTTLOverrides !== undefined
@@ -1100,4 +1121,4 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));

package/dist/umd/es2018/makeDurable/cachepolicies/cache-and-network.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/cache-then-network.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/no-cache.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/only-if-cached.d.ts

@@ -1,3 +1,3 @@
-import { CachePolicyImplementationArgs, ErrorSnapshot, Snapshot } from '@luvio/engine';
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/stale-while-revalidate.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/utils.d.ts

@@ -3,5 +3,6 @@ export declare type DurableCachePolicyFunctions = {
     validateNotDisposed: () => void;
     reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
 };
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];
+export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
+export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;

package/dist/umd/es2018/utils/language.d.ts

@@ -14,6 +14,6 @@ declare const keys: {
     <T_1 extends Function>(f: T_1): T_1;
     <T_2>(o: T_2): Readonly<T_2>;
 };
-declare const hasOwnProperty: (v: string | number | symbol) => boolean;
+declare const hasOwnProperty: (v: PropertyKey) => boolean;
 declare const isArray: (arg: any) => arg is any[];
 export { create as ObjectCreate, keys as ObjectKeys, assign as ObjectAssign, freeze as ObjectFreeze, hasOwnProperty as ObjectPrototypeHasOwnProperty, isArray as ArrayIsArray, };

package/dist/umd/es5/environments.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
     typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
-    (global = global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
-}(this, (function (exports, engine) { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
+})(this, (function (exports, engine) { 'use strict';
 
     function isDeprecatedDurableStoreEntry(durableRecord) {
         if (durableRecord.expiration !== undefined) {
@@ -11,6 +11,7 @@
         // Add more deprecated shape checks here
         return false;
     }
+    exports.DurableStoreOperationType = void 0;
     (function (DurableStoreOperationType) {
         DurableStoreOperationType["SetEntries"] = "setEntries";
         DurableStoreOperationType["EvictEntries"] = "evictEntries";
@@ -18,18 +19,18 @@
     var DefaultDurableSegment = 'DEFAULT';
 
     /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation. All rights reserved.
-    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-    this file except in compliance with the License. You may obtain a copy of the
-    License at http://www.apache.org/licenses/LICENSE-2.0
+    Copyright (c) Microsoft Corporation.
 
-    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-    MERCHANTABLITY OR NON-INFRINGEMENT.
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
 
-    See the Apache Version 2.0 License for specific language governing permissions
-    and limitations under the License.
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
 
     var __assign = function() {
@@ -43,17 +44,30 @@
         return __assign.apply(this, arguments);
     };
 
-    function __spreadArrays() {
-        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-        for (var r = Array(s), k = 0, i = 0; i < il; i++)
-            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-                r[k] = a[j];
-        return r;
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
     }
 
     var keys = Object.keys, create = Object.create, assign = Object.assign, freeze = Object.freeze;
     var isArray = Array.isArray;
 
+    function appendTTLStrategy(storeLookup, ttlStrategy) {
+        return function (sel, refresh) {
+            return storeLookup(sel, refresh, ttlStrategy);
+        };
+    }
+    function buildNetworkSnapshot(args) {
+        var buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext;
+        return buildNetworkSnapshot(buildSnapshotContext).then(function (snapshot) {
+            return snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot;
+        });
+    }
     function buildTTLStrategy(staleDurationMilliseconds) {
         if (staleDurationMilliseconds === void 0) { staleDurationMilliseconds = 0; }
         return function (timestamp, metadata, valueIsError) {
@@ -72,17 +86,12 @@
             }
             return engine.StoreResolveResultState.Found;
         };
-    }
-    function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return function (sel, refresh) {
-            return storeLookup(sel, refresh, ttlStrategy);
-        };
     }
 
     function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot$1 = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
@@ -90,10 +99,16 @@
                 // data found in L1 cache
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     // kick off network request, do not await it
-                    buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    buildNetworkSnapshot$1(buildSnapshotContext);
                     // return the cached snapshot to caller
                     return snapshot;
                 }
+                // network request outstanding
+                if (snapshot.state === 'Pending') {
+                    // kick off another network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext);
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
                     // kick off network request, do not await it
@@ -111,11 +126,15 @@
                         if (revivedSnapshot.state === 'Fulfilled' ||
                             revivedSnapshot.state === 'Error') {
                             // kick off network request, do not await it
-                            buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            buildNetworkSnapshot$1(buildSnapshotContext);
                             // return the L2 cached snapshot to caller
                             return revivedSnapshot;
                         }
-                        if (revivedSnapshot.state === 'Pending') ;
+                        if (revivedSnapshot.state === 'Pending') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext);
+                            return args.resolvePendingSnapshot(revivedSnapshot);
+                        }
                         // stale data found in L2 cache
                         if (revivedSnapshot.state === 'Stale') {
                             // kick off network request, do not await it
@@ -125,19 +144,18 @@
                             return revivedSnapshot;
                         }
                         // data not found in L2 cache, go to the network
-                        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        return buildNetworkSnapshot(args);
                     });
                 }
-                if (snapshot.state === 'Pending') ;
             }
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildCacheThenNetworkImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -145,7 +163,9 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // data not found in L1 cache, try L2 cache
                 return funcs
                     .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -155,24 +175,22 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildNoCacheImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest;
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then(function (snapshot) {
-                if (snapshot.state === 'Pending') ;
-                return snapshot;
-            });
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -209,6 +227,8 @@
             error: error,
             state: 'Error',
             data: undefined,
+            // TODO[@W-10164067]: copy refresh data from the snapshot returned by buildInMemorySnapshot (if any)
+            // refresh: ...
         };
     }
     function buildOnlyIfCachedImplementation(funcs) {
@@ -246,7 +266,7 @@
     function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -254,11 +274,13 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
-                    // offline environment is already doing this; uncomment once we get rid of offline environment
-                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(args);
                     return snapshot;
                 }
                 // data not found in L1 cache, try L2 cache
@@ -270,19 +292,21 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // stale data found in L2 cache
                     if (revivedSnapshot.state === 'Stale') {
-                        // offline environment is already doing this; uncomment once we get rid of offline environment
-                        // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                        // buildNetworkSnapshot(args);
                         return revivedSnapshot;
                     }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -346,16 +370,16 @@
         for (var i = 0, len = selections.length; i < len; i++) {
             var selection = selections[i];
             if (selection.kind === 'Object') {
-                nestedSelections = __spreadArrays(nestedSelections, getSelections(selection.selections));
+                nestedSelections = __spreadArray(__spreadArray([], nestedSelections, true), getSelections(selection.selections), true);
             }
             else if (selection.kind === 'Link') {
-                nestedSelections = __spreadArrays(nestedSelections, getSelectionsFromFragment(selection.fragment));
+                nestedSelections = __spreadArray(__spreadArray([], nestedSelections, true), getSelectionsFromFragment(selection.fragment), true);
             }
             else {
                 nonNestedSelections.push(selection);
             }
         }
-        return __spreadArrays(nestedSelections, nonNestedSelections);
+        return __spreadArray(__spreadArray([], nestedSelections, true), nonNestedSelections, true);
     }
     function getSelectionsFromFragment(fragment) {
         var selections = [];
@@ -365,7 +389,7 @@
             var unionKeys = keys(unionSelections);
             for (var i = 0, len = unionKeys.length; i < len; i++) {
                 var key = unionKeys[i];
-                selections = __spreadArrays(selections, unionSelections[key].selections);
+                selections = __spreadArray(__spreadArray([], selections, true), unionSelections[key].selections, true);
             }
         }
         // if fragment has selections properties then get them
@@ -546,7 +570,7 @@
     var TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
     var TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
     function buildDurableTTLOverrideStoreKey(namespace, representationName) {
-        return namespace + "::" + representationName;
+        return "".concat(namespace, "::").concat(representationName);
     }
     function isEntryDurableTTLOverride(entry) {
         if (typeof entry === 'object' && entry !== undefined && entry !== null) {
@@ -629,7 +653,7 @@
         }
         if (isArray(source)) {
             // TS doesn't trust that this new array is an array unless we cast it
-            return __spreadArrays(source);
+            return __spreadArray([], source, true);
         }
         return __assign({}, source);
     }
@@ -821,7 +845,7 @@
             if (ingestStagingStore === null) {
                 ingestStagingStore = new engine.Store();
             }
-            return environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
         };
         var storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
             validateNotDisposed();
@@ -927,7 +951,7 @@
             validateNotDisposed();
             var contextId = options.contextId, onContextLoaded = options.onContextLoaded;
             var context = undefined;
-            var contextAsPromise = reviveOrCreateContext(contextId === undefined ? adapter.name : "" + contextId + ADAPTER_CONTEXT_ID_SUFFIX, durableStore, durableStoreErrorHandler, onContextLoaded);
+            var contextAsPromise = reviveOrCreateContext(contextId === undefined ? adapter.name : "".concat(contextId).concat(ADAPTER_CONTEXT_ID_SUFFIX), durableStore, durableStoreErrorHandler, onContextLoaded);
             return function (config, requestContext) {
                 if (context === undefined) {
                     return contextAsPromise.then(function (revivedContext) {
@@ -1008,7 +1032,7 @@
                 }
                 default: {
                     if (process.env.NODE_ENV !== 'production') {
-                        throw new Error("unrecognized cache policy: " + JSON.stringify(cachePolicy));
+                        throw new Error("unrecognized cache policy: ".concat(JSON.stringify(cachePolicy)));
                     }
                     return defaultCachePolicy;
                 }
@@ -1017,14 +1041,17 @@
         var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             var cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
+            var resolvePendingSnapshot = function (snapshot) {
+                return environment.resolvePendingSnapshot(snapshot);
+            };
             var storeLookup = function (sel, refresh, ttlStrategy) { return environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy); };
             var applyCachePolicy = function () {
                 return cachePolicyImpl({
                     buildInMemorySnapshot: buildInMemorySnapshot,
                     buildNetworkSnapshot: buildNetworkSnapshot,
                     buildSnapshotContext: buildSnapshotContext,
+                    resolvePendingSnapshot: resolvePendingSnapshot,
                     storeLookup: storeLookup,
-                    dispatchResourceRequest: environment.dispatchResourceRequest,
                 });
             };
             return isRevivingTTLOverrides !== undefined
@@ -1140,4 +1167,4 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));

package/dist/umd/es5/makeDurable/cachepolicies/cache-and-network.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/cache-then-network.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/no-cache.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/only-if-cached.d.ts

@@ -1,3 +1,3 @@
-import { CachePolicyImplementationArgs, ErrorSnapshot, Snapshot } from '@luvio/engine';
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/stale-while-revalidate.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => Snapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/utils.d.ts

@@ -3,5 +3,6 @@ export declare type DurableCachePolicyFunctions = {
     validateNotDisposed: () => void;
     reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
 };
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];
+export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
+export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;

package/dist/umd/es5/utils/language.d.ts

@@ -14,6 +14,6 @@ declare const keys: {
     <T_1 extends Function>(f: T_1): T_1;
     <T_2>(o: T_2): Readonly<T_2>;
 };
-declare const hasOwnProperty: (v: string | number | symbol) => boolean;
+declare const hasOwnProperty: (v: PropertyKey) => boolean;
 declare const isArray: (arg: any) => arg is any[];
 export { create as ObjectCreate, keys as ObjectKeys, assign as ObjectAssign, freeze as ObjectFreeze, hasOwnProperty as ObjectPrototypeHasOwnProperty, isArray as ArrayIsArray, };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.62.3",
+    "version": "0.63.2",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -17,6 +17,6 @@
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.62.3"
+        "@luvio/engine": "0.63.2"
     }
 }