@luvio/environments 0.58.1 → 0.61.0-236.0

package/dist/es/es2018/ReaderWithPrivateProperties.d.ts

@@ -0,0 +1,4 @@
+import { Fragment, FragmentUnionSelection, ObjectSelection, Reader, ReaderFragment } from '@luvio/engine';
+export declare class ReaderWithPrivateProperties<V> extends Reader<V> {
+    traverseSelections(node: ObjectSelection | Exclude<Fragment, FragmentUnionSelection | ReaderFragment>, record: any, data: any): void;
+}

package/dist/es/es2018/environments.js

@@ -1,4 +1,4 @@
-import { StoreResolveResultState, Store, buildStaleWhileRevalidateImplementation as buildStaleWhileRevalidateImplementation$1 } from '@luvio/engine';
+import { StoreResolveResultState, HttpStatusCode, Store, buildStaleWhileRevalidateImplementation as buildStaleWhileRevalidateImplementation$1 } from '@luvio/engine';
 
 function isDeprecatedDurableStoreEntry(durableRecord) {
     if (durableRecord.expiration !== undefined) {
@@ -17,12 +17,13 @@ const DefaultDurableSegment = 'DEFAULT';
 const { keys, create, assign, freeze } = Object;
 const { isArray } = Array;
 
-function buildTTLStrategy(staleDuration = 0) {
+function buildTTLStrategy(staleDurationMilliseconds = 0) {
     return (timestamp, metadata, valueIsError) => {
         if (metadata !== undefined) {
             const { expirationTimestamp } = metadata;
             if (timestamp > expirationTimestamp) {
-                if (timestamp <= expirationTimestamp + staleDuration && valueIsError !== true) {
+                if (timestamp <= expirationTimestamp + staleDurationMilliseconds &&
+                    valueIsError !== true) {
                     return StoreResolveResultState.Stale;
                 }
                 return StoreResolveResultState.NotPresent;
@@ -38,11 +39,175 @@ function appendTTLStrategy(storeLookup, ttlStrategy) {
     return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
 }
 
-function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
     return function (args) {
         funcs.validateNotDisposed();
         const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
-        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+        const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
+        const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+        if (snapshot !== undefined) {
+            // data found in L1 cache
+            if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                // kick off network request, do not await it
+                buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                // return the cached snapshot to caller
+                return snapshot;
+            }
+            // stale data found in L1 cache
+            if (snapshot.state === 'Stale') {
+                // kick off network request, do not await it
+                // offline environment is already doing this; uncomment once we get rid of offline environment
+                // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                // return the cached snapshot to caller
+                return snapshot;
+            }
+            // if unfulfilled we have enough info to do an L2 lookup
+            if (snapshot.state === 'Unfulfilled') {
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then((revivedSnapshot) => {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        // kick off network request, do not await it
+                        buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        // return the L2 cached snapshot to caller
+                        return revivedSnapshot;
+                    }
+                    if (revivedSnapshot.state === 'Pending') ;
+                    // stale data found in L2 cache
+                    if (revivedSnapshot.state === 'Stale') {
+                        // kick off network request, do not await it
+                        // offline environment is already doing this; uncomment once we get rid of offline environment
+                        // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        // return the L2 cached snapshot to caller
+                        return revivedSnapshot;
+                    }
+                    // data not found in L2 cache, go to the network
+                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                });
+            }
+            if (snapshot.state === 'Pending') ;
+        }
+        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+    };
+}
+
+function buildCacheThenNetworkImplementation(funcs) {
+    return function (args) {
+        funcs.validateNotDisposed();
+        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+        const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+        if (snapshot !== undefined) {
+            // data found in L1 cache
+            if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                return snapshot;
+            }
+            if (snapshot.state === 'Pending') ;
+            // data not found in L1 cache, try L2 cache
+            return funcs
+                .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                .then((revivedSnapshot) => {
+                // data found in L2 cache
+                if (revivedSnapshot.state === 'Fulfilled' ||
+                    revivedSnapshot.state === 'Error') {
+                    return revivedSnapshot;
+                }
+                if (revivedSnapshot.state === 'Pending') ;
+                // data not found in L2 cache, go to the network
+                return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            });
+        }
+        // L1 lookup could not find enough information to even construct a snapshot, go to the network
+        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+    };
+}
+
+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;
+        });
+    };
+}
+
+function deepFreeze(value) {
+    // No need to freeze primitives
+    if (typeof value !== 'object' || value === null) {
+        return;
+    }
+    if (isArray(value)) {
+        for (let i = 0, len = value.length; i < len; i += 1) {
+            deepFreeze(value[i]);
+        }
+    }
+    else {
+        const keys$1 = keys(value);
+        for (let i = 0, len = keys$1.length; i < len; i += 1) {
+            deepFreeze(value[keys$1[i]]);
+        }
+    }
+    freeze(value);
+}
+
+// TODO[@W-10165595]: consolidate this code with the corresponding logic in the default environment's only-if-cached.ts
+function buildNotCachedErrorSnapshot() {
+    const error = {
+        body: undefined,
+        headers: {},
+        ok: false,
+        status: HttpStatusCode.GatewayTimeout,
+        statusText: 'Gateway Timeout',
+    };
+    deepFreeze(error);
+    return {
+        error,
+        state: 'Error',
+        data: undefined,
+    };
+}
+function buildOnlyIfCachedImplementation(funcs) {
+    return function (args) {
+        funcs.validateNotDisposed();
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+        const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+        if (snapshot !== undefined) {
+            // data found in L1 cache
+            if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                return snapshot;
+            }
+            // network request outstanding, data is not cached
+            if (snapshot.state === 'Pending') {
+                return buildNotCachedErrorSnapshot();
+            }
+            // data not found in L1 cache, try L2 cache
+            return funcs
+                .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                .then((revivedSnapshot) => {
+                // data found in L2 cache
+                if (revivedSnapshot.state === 'Fulfilled' ||
+                    revivedSnapshot.state === 'Error') {
+                    return revivedSnapshot;
+                }
+                // data is not cached
+                return buildNotCachedErrorSnapshot();
+            });
+        }
+        return buildNotCachedErrorSnapshot();
+    };
+}
+
+function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
+    return function (args) {
+        funcs.validateNotDisposed();
+        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
         if (snapshot !== undefined) {
             // data found in L1 cache
@@ -105,25 +270,6 @@ function handleDurableStoreRejection(instrument) {
     };
 }
 
-function deepFreeze(value) {
-    // No need to freeze primitives
-    if (typeof value !== 'object' || value === null) {
-        return;
-    }
-    if (isArray(value)) {
-        for (let i = 0, len = value.length; i < len; i += 1) {
-            deepFreeze(value[i]);
-        }
-    }
-    else {
-        const keys$1 = keys(value);
-        for (let i = 0, len = keys$1.length; i < len; i += 1) {
-            deepFreeze(value[keys$1[i]]);
-        }
-    }
-    freeze(value);
-}
-
 const SELECTOR_PAGINATION_TOKEN = 'tokenDataKey';
 function isFragmentUnionSelection(sel) {
     return sel.union === true;
@@ -272,7 +418,9 @@ function publishDurableStoreEntries(durableRecords, publish, publishMetadata) {
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
+function reviveSnapshot(baseEnvironment, durableStore, 
+// TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
+unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
     const { recordId, select, seenRecords, state } = unavailableSnapshot;
     // L2 can only revive Unfulfilled snapshots that have a selector since they have the
     // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
@@ -764,7 +912,27 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 return buildStaleWhileRevalidateImplementation({
                     validateNotDisposed,
                     reviveSnapshotWithCachePolicy,
-                }, cachePolicy.staleDuration);
+                }, cachePolicy.staleDurationSeconds);
+            case 'cache-and-network':
+                return buildCacheAndNetworkImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                }, cachePolicy.staleDurationSeconds);
+            case 'cache-then-network':
+                return buildCacheThenNetworkImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                });
+            case 'no-cache':
+                return buildNoCacheImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                });
+            case 'only-if-cached':
+                return buildOnlyIfCachedImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                });
             default: {
                 if (process.env.NODE_ENV !== 'production') {
                     throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);

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

@@ -0,0 +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>>;

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

@@ -0,0 +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>>;

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

@@ -1 +1,5 @@
+export { buildCacheAndNetworkImplementation } from './cache-and-network';
+export { buildCacheThenNetworkImplementation } from './cache-then-network';
+export { buildNoCacheImplementation } from './no-cache';
+export { buildOnlyIfCachedImplementation } from './only-if-cached';
 export { buildStaleWhileRevalidateImplementation } from './stale-while-revalidate';

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

@@ -0,0 +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>>;

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

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, ErrorSnapshot, 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>>;

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, staleDuration: 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>) => 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>>;

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

@@ -3,5 +3,5 @@ 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(staleDuration?: number): TTLStrategy;
+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];

package/dist/es/es2018/makeDurable/pendingWriter.d.ts

@@ -0,0 +1,16 @@
+import { Environment } from '@luvio/engine';
+import { DurableStore } from '../DurableStore';
+import { DurableStoreRejectionHandler } from './error';
+export interface FlushResult {
+    flushedKeys: Set<string>;
+}
+export interface PendingWriter {
+    clearPendingWrites(): void;
+    addPendingWrite(key: string): void;
+    removePendingWrite(key: string): void;
+    hasPendingWrite(key: string): boolean;
+    flushPendingWritesToDurableStore(environment: Environment, durableStore: DurableStore, durableStoreErrorHandler: DurableStoreRejectionHandler): Promise<void>;
+    getLastFlushResult(): FlushResult | undefined;
+    resetLastFlushResult(): void;
+}
+export declare function buildPendingWriter(): PendingWriter;

package/dist/es/es2018/makeDurable/refresh.d.ts

@@ -0,0 +1,3 @@
+import { Environment, Snapshot, SnapshotRefresh, UnAvailableSnapshot } from '@luvio/engine';
+import { PendingWriter } from './pendingWriter';
+export declare function buildDurableStoreAwareRefresh<ResponseType>(refresh: SnapshotRefresh<ResponseType>, snapshot: UnAvailableSnapshot<ResponseType>, environment: Environment, pendingWriter: PendingWriter): () => Promise<Snapshot<ResponseType>>;

package/dist/umd/es2018/ReaderWithPrivateProperties.d.ts

@@ -0,0 +1,4 @@
+import { Fragment, FragmentUnionSelection, ObjectSelection, Reader, ReaderFragment } from '@luvio/engine';
+export declare class ReaderWithPrivateProperties<V> extends Reader<V> {
+    traverseSelections(node: ObjectSelection | Exclude<Fragment, FragmentUnionSelection | ReaderFragment>, record: any, data: any): void;
+}

package/dist/umd/es2018/environments.js

@@ -20,12 +20,13 @@
     const { keys, create, assign, freeze } = Object;
     const { isArray } = Array;
 
-    function buildTTLStrategy(staleDuration = 0) {
+    function buildTTLStrategy(staleDurationMilliseconds = 0) {
         return (timestamp, metadata, valueIsError) => {
             if (metadata !== undefined) {
                 const { expirationTimestamp } = metadata;
                 if (timestamp > expirationTimestamp) {
-                    if (timestamp <= expirationTimestamp + staleDuration && valueIsError !== true) {
+                    if (timestamp <= expirationTimestamp + staleDurationMilliseconds &&
+                        valueIsError !== true) {
                         return engine.StoreResolveResultState.Stale;
                     }
                     return engine.StoreResolveResultState.NotPresent;
@@ -41,11 +42,175 @@
         return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
     }
 
-    function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+    function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
             const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
-            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+            const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
+            const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    // kick off network request, do not await it
+                    buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
+                    return snapshot;
+                }
+                // stale data found in L1 cache
+                if (snapshot.state === 'Stale') {
+                    // kick off network request, do not await it
+                    // offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
+                    return snapshot;
+                }
+                // if unfulfilled we have enough info to do an L2 lookup
+                if (snapshot.state === 'Unfulfilled') {
+                    return funcs
+                        .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                        .then((revivedSnapshot) => {
+                        // data found in L2 cache
+                        if (revivedSnapshot.state === 'Fulfilled' ||
+                            revivedSnapshot.state === 'Error') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        if (revivedSnapshot.state === 'Pending') ;
+                        // stale data found in L2 cache
+                        if (revivedSnapshot.state === 'Stale') {
+                            // kick off network request, do not await it
+                            // offline environment is already doing this; uncomment once we get rid of offline environment
+                            // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        // data not found in L2 cache, go to the network
+                        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    });
+                }
+                if (snapshot.state === 'Pending') ;
+            }
+            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        };
+    }
+
+    function buildCacheThenNetworkImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                if (snapshot.state === 'Pending') ;
+                // data not found in L1 cache, try L2 cache
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then((revivedSnapshot) => {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    if (revivedSnapshot.state === 'Pending') ;
+                    // data not found in L2 cache, go to the network
+                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                });
+            }
+            // L1 lookup could not find enough information to even construct a snapshot, go to the network
+            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        };
+    }
+
+    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;
+            });
+        };
+    }
+
+    function deepFreeze(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (isArray(value)) {
+            for (let i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            const keys$1 = keys(value);
+            for (let i = 0, len = keys$1.length; i < len; i += 1) {
+                deepFreeze(value[keys$1[i]]);
+            }
+        }
+        freeze(value);
+    }
+
+    // TODO[@W-10165595]: consolidate this code with the corresponding logic in the default environment's only-if-cached.ts
+    function buildNotCachedErrorSnapshot() {
+        const error = {
+            body: undefined,
+            headers: {},
+            ok: false,
+            status: engine.HttpStatusCode.GatewayTimeout,
+            statusText: 'Gateway Timeout',
+        };
+        deepFreeze(error);
+        return {
+            error,
+            state: 'Error',
+            data: undefined,
+        };
+    }
+    function buildOnlyIfCachedImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                // network request outstanding, data is not cached
+                if (snapshot.state === 'Pending') {
+                    return buildNotCachedErrorSnapshot();
+                }
+                // data not found in L1 cache, try L2 cache
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then((revivedSnapshot) => {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    // data is not cached
+                    return buildNotCachedErrorSnapshot();
+                });
+            }
+            return buildNotCachedErrorSnapshot();
+        };
+    }
+
+    function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
                 // data found in L1 cache
@@ -108,25 +273,6 @@
         };
     }
 
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (let i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            const keys$1 = keys(value);
-            for (let i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze(value[keys$1[i]]);
-            }
-        }
-        freeze(value);
-    }
-
     const SELECTOR_PAGINATION_TOKEN = 'tokenDataKey';
     function isFragmentUnionSelection(sel) {
         return sel.union === true;
@@ -275,7 +421,9 @@
      * will refresh the snapshot from network, and then run the results from network
      * through L2 ingestion, returning the subsequent revived snapshot.
      */
-    function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
+    function reviveSnapshot(baseEnvironment, durableStore, 
+    // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
+    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
         const { recordId, select, seenRecords, state } = unavailableSnapshot;
         // L2 can only revive Unfulfilled snapshots that have a selector since they have the
         // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
@@ -767,7 +915,27 @@
                     return buildStaleWhileRevalidateImplementation({
                         validateNotDisposed,
                         reviveSnapshotWithCachePolicy,
-                    }, cachePolicy.staleDuration);
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-and-network':
+                    return buildCacheAndNetworkImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-then-network':
+                    return buildCacheThenNetworkImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    });
+                case 'no-cache':
+                    return buildNoCacheImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    });
+                case 'only-if-cached':
+                    return buildOnlyIfCachedImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    });
                 default: {
                     if (process.env.NODE_ENV !== 'production') {
                         throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);

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

@@ -0,0 +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>>;

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

@@ -0,0 +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>>;

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

@@ -1 +1,5 @@
+export { buildCacheAndNetworkImplementation } from './cache-and-network';
+export { buildCacheThenNetworkImplementation } from './cache-then-network';
+export { buildNoCacheImplementation } from './no-cache';
+export { buildOnlyIfCachedImplementation } from './only-if-cached';
 export { buildStaleWhileRevalidateImplementation } from './stale-while-revalidate';

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

@@ -0,0 +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>>;

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

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, ErrorSnapshot, 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>>;

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, staleDuration: 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>) => 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>>;

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

@@ -3,5 +3,5 @@ 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(staleDuration?: number): TTLStrategy;
+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];

package/dist/umd/es2018/makeDurable/pendingWriter.d.ts

@@ -0,0 +1,16 @@
+import { Environment } from '@luvio/engine';
+import { DurableStore } from '../DurableStore';
+import { DurableStoreRejectionHandler } from './error';
+export interface FlushResult {
+    flushedKeys: Set<string>;
+}
+export interface PendingWriter {
+    clearPendingWrites(): void;
+    addPendingWrite(key: string): void;
+    removePendingWrite(key: string): void;
+    hasPendingWrite(key: string): boolean;
+    flushPendingWritesToDurableStore(environment: Environment, durableStore: DurableStore, durableStoreErrorHandler: DurableStoreRejectionHandler): Promise<void>;
+    getLastFlushResult(): FlushResult | undefined;
+    resetLastFlushResult(): void;
+}
+export declare function buildPendingWriter(): PendingWriter;

package/dist/umd/es2018/makeDurable/refresh.d.ts

@@ -0,0 +1,3 @@
+import { Environment, Snapshot, SnapshotRefresh, UnAvailableSnapshot } from '@luvio/engine';
+import { PendingWriter } from './pendingWriter';
+export declare function buildDurableStoreAwareRefresh<ResponseType>(refresh: SnapshotRefresh<ResponseType>, snapshot: UnAvailableSnapshot<ResponseType>, environment: Environment, pendingWriter: PendingWriter): () => Promise<Snapshot<ResponseType>>;

package/dist/umd/es5/ReaderWithPrivateProperties.d.ts

@@ -0,0 +1,4 @@
+import { Fragment, FragmentUnionSelection, ObjectSelection, Reader, ReaderFragment } from '@luvio/engine';
+export declare class ReaderWithPrivateProperties<V> extends Reader<V> {
+    traverseSelections(node: ObjectSelection | Exclude<Fragment, FragmentUnionSelection | ReaderFragment>, record: any, data: any): void;
+}

package/dist/umd/es5/environments.js

@@ -54,13 +54,14 @@
     var keys = Object.keys, create = Object.create, assign = Object.assign, freeze = Object.freeze;
     var isArray = Array.isArray;
 
-    function buildTTLStrategy(staleDuration) {
-        if (staleDuration === void 0) { staleDuration = 0; }
+    function buildTTLStrategy(staleDurationMilliseconds) {
+        if (staleDurationMilliseconds === void 0) { staleDurationMilliseconds = 0; }
         return function (timestamp, metadata, valueIsError) {
             if (metadata !== undefined) {
                 var expirationTimestamp = metadata.expirationTimestamp;
                 if (timestamp > expirationTimestamp) {
-                    if (timestamp <= expirationTimestamp + staleDuration && valueIsError !== true) {
+                    if (timestamp <= expirationTimestamp + staleDurationMilliseconds &&
+                        valueIsError !== true) {
                         return engine.StoreResolveResultState.Stale;
                     }
                     return engine.StoreResolveResultState.NotPresent;
@@ -78,11 +79,175 @@
         };
     }
 
-    function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+    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 cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+            var staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
+            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    // kick off network request, do not await it
+                    buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
+                    return snapshot;
+                }
+                // stale data found in L1 cache
+                if (snapshot.state === 'Stale') {
+                    // kick off network request, do not await it
+                    // offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
+                    return snapshot;
+                }
+                // if unfulfilled we have enough info to do an L2 lookup
+                if (snapshot.state === 'Unfulfilled') {
+                    return funcs
+                        .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                        .then(function (revivedSnapshot) {
+                        // data found in L2 cache
+                        if (revivedSnapshot.state === 'Fulfilled' ||
+                            revivedSnapshot.state === 'Error') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        if (revivedSnapshot.state === 'Pending') ;
+                        // stale data found in L2 cache
+                        if (revivedSnapshot.state === 'Stale') {
+                            // kick off network request, do not await it
+                            // offline environment is already doing this; uncomment once we get rid of offline environment
+                            // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        // data not found in L2 cache, go to the network
+                        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    });
+                }
+                if (snapshot.state === 'Pending') ;
+            }
+            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        };
+    }
+
+    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 cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                if (snapshot.state === 'Pending') ;
+                // data not found in L1 cache, try L2 cache
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then(function (revivedSnapshot) {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    if (revivedSnapshot.state === 'Pending') ;
+                    // data not found in L2 cache, go to the network
+                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                });
+            }
+            // L1 lookup could not find enough information to even construct a snapshot, go to the network
+            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        };
+    }
+
+    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;
+            });
+        };
+    }
+
+    function deepFreeze(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (isArray(value)) {
+            for (var i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            var keys$1 = keys(value);
+            for (var i = 0, len = keys$1.length; i < len; i += 1) {
+                deepFreeze(value[keys$1[i]]);
+            }
+        }
+        freeze(value);
+    }
+
+    // TODO[@W-10165595]: consolidate this code with the corresponding logic in the default environment's only-if-cached.ts
+    function buildNotCachedErrorSnapshot() {
+        var error = {
+            body: undefined,
+            headers: {},
+            ok: false,
+            status: engine.HttpStatusCode.GatewayTimeout,
+            statusText: 'Gateway Timeout',
+        };
+        deepFreeze(error);
+        return {
+            error: error,
+            state: 'Error',
+            data: undefined,
+        };
+    }
+    function buildOnlyIfCachedImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
+            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                // network request outstanding, data is not cached
+                if (snapshot.state === 'Pending') {
+                    return buildNotCachedErrorSnapshot();
+                }
+                // data not found in L1 cache, try L2 cache
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then(function (revivedSnapshot) {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    // data is not cached
+                    return buildNotCachedErrorSnapshot();
+                });
+            }
+            return buildNotCachedErrorSnapshot();
+        };
+    }
+
+    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 cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
                 // data found in L1 cache
@@ -146,25 +311,6 @@
         };
     }
 
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (var i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            var keys$1 = keys(value);
-            for (var i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze(value[keys$1[i]]);
-            }
-        }
-        freeze(value);
-    }
-
     var SELECTOR_PAGINATION_TOKEN = 'tokenDataKey';
     function isFragmentUnionSelection(sel) {
         return sel.union === true;
@@ -307,7 +453,9 @@
      * will refresh the snapshot from network, and then run the results from network
      * through L2 ingestion, returning the subsequent revived snapshot.
      */
-    function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
+    function reviveSnapshot(baseEnvironment, durableStore, 
+    // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
+    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
         var _a;
         var recordId = unavailableSnapshot.recordId, select = unavailableSnapshot.select, seenRecords = unavailableSnapshot.seenRecords, state = unavailableSnapshot.state;
         // L2 can only revive Unfulfilled snapshots that have a selector since they have the
@@ -809,7 +957,27 @@
                     return buildStaleWhileRevalidateImplementation({
                         validateNotDisposed: validateNotDisposed,
                         reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
-                    }, cachePolicy.staleDuration);
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-and-network':
+                    return buildCacheAndNetworkImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-then-network':
+                    return buildCacheThenNetworkImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    });
+                case 'no-cache':
+                    return buildNoCacheImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    });
+                case 'only-if-cached':
+                    return buildOnlyIfCachedImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    });
                 default: {
                     if (process.env.NODE_ENV !== 'production') {
                         throw new Error("unrecognized cache policy: " + JSON.stringify(cachePolicy));

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

@@ -0,0 +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>>;

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

@@ -0,0 +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>>;

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

@@ -1 +1,5 @@
+export { buildCacheAndNetworkImplementation } from './cache-and-network';
+export { buildCacheThenNetworkImplementation } from './cache-then-network';
+export { buildNoCacheImplementation } from './no-cache';
+export { buildOnlyIfCachedImplementation } from './only-if-cached';
 export { buildStaleWhileRevalidateImplementation } from './stale-while-revalidate';

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

@@ -0,0 +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>>;

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

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, ErrorSnapshot, 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>>;

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, staleDuration: 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>) => 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>>;

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

@@ -3,5 +3,5 @@ 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(staleDuration?: number): TTLStrategy;
+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];

package/dist/umd/es5/makeDurable/pendingWriter.d.ts

@@ -0,0 +1,16 @@
+import { Environment } from '@luvio/engine';
+import { DurableStore } from '../DurableStore';
+import { DurableStoreRejectionHandler } from './error';
+export interface FlushResult {
+    flushedKeys: Set<string>;
+}
+export interface PendingWriter {
+    clearPendingWrites(): void;
+    addPendingWrite(key: string): void;
+    removePendingWrite(key: string): void;
+    hasPendingWrite(key: string): boolean;
+    flushPendingWritesToDurableStore(environment: Environment, durableStore: DurableStore, durableStoreErrorHandler: DurableStoreRejectionHandler): Promise<void>;
+    getLastFlushResult(): FlushResult | undefined;
+    resetLastFlushResult(): void;
+}
+export declare function buildPendingWriter(): PendingWriter;

package/dist/umd/es5/makeDurable/refresh.d.ts

@@ -0,0 +1,3 @@
+import { Environment, Snapshot, SnapshotRefresh, UnAvailableSnapshot } from '@luvio/engine';
+import { PendingWriter } from './pendingWriter';
+export declare function buildDurableStoreAwareRefresh<ResponseType>(refresh: SnapshotRefresh<ResponseType>, snapshot: UnAvailableSnapshot<ResponseType>, environment: Environment, pendingWriter: PendingWriter): () => Promise<Snapshot<ResponseType>>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.58.1",
+    "version": "0.61.0-236.0",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -16,6 +16,7 @@
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.58.1"
-    }
+        "@luvio/engine": "0.61.0-236.0"
+    },
+    "gitHead": "4b95b09a954e65b46e5c5e004717349a046113de"
 }