@luvio/environments 0.48.3 → 0.49.0

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

@@ -1,8 +1,24 @@
 /**
  * Contains store entry data along with any metadata for that entry that needs
  * to be persisted to durable storage
+ *
+ * IMPORTANT: if you update this interface, you must also create a
+ * deprecated interface, and check for durable store entries of this
+ * type in isDeprecatedDurableStoreEntry so that revive discards
+ * invalid entries.
  */
 export interface DurableStoreEntry<T = unknown> {
+    data: T;
+    metadata?: {
+        ingestionTimestamp: number;
+        expirationTimestamp: number;
+        staleTimestamp?: number;
+        namespace: string;
+        representationName: string;
+    };
+}
+export declare function isDeprecatedDurableStoreEntry(durableRecord: unknown): boolean;
+export interface DeprecatedDurableStoreEntry1<T = unknown> {
     data: T;
     expiration?: {
         fresh: number;

package/dist/es/es2018/environments.js

@@ -1,3 +1,10 @@
+function isDeprecatedDurableStoreEntry(durableRecord) {
+    if (durableRecord.expiration !== undefined) {
+        return true;
+    }
+    // Add more deprecated shape checks here
+    return false;
+}
 var DurableStoreOperationType;
 (function (DurableStoreOperationType) {
     DurableStoreOperationType["SetEntries"] = "setEntries";
@@ -62,7 +69,7 @@ function buildPendingWriter() {
         flushPendingWritesToDurableStore: function (environment, durableStore, durableStoreErrorHandler) {
             const durableRecords = create({});
             const records = environment.getStoreRecords();
-            const expirations = environment.getStoreRecordExpirations();
+            const storeMetadataMap = environment.getStoreMetadataMap();
             const keys$1 = keys(pendingDurableWrites);
             for (let i = 0, len = keys$1.length; i < len; i += 1) {
                 const key = keys$1[i];
@@ -71,12 +78,12 @@ function buildPendingWriter() {
                 if (record === undefined) {
                     continue;
                 }
-                const ttl = expirations[key];
+                const recordMetadata = storeMetadataMap[key];
                 durableRecords[key] = {
                     // make copy of record b/c evict is coming
                     // NOTE: only spread copy if an array or object
                     data: copy(record),
-                    expiration: ttl,
+                    metadata: recordMetadata,
                 };
                 // remove record from L1 cache while we are on the synchronous path
                 // because we do not want some other code attempting to use the
@@ -250,8 +257,8 @@ function buildDurableStoreAwareRefresh(refresh, snapshot, environment, pendingWr
 function isStoreEntryError(storeRecord) {
     return storeRecord.__type === 'error';
 }
-function isStoreEntryExpiredAndError(storeRecord, fresh, now) {
-    return isStoreEntryError(storeRecord) && fresh < now;
+function isStoreEntryExpiredAndError(storeRecord, expirationTimestamp, now) {
+    return isStoreEntryError(storeRecord) && expirationTimestamp < now;
 }
 function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter) {
     const revivedKeys = create(null);
@@ -268,37 +275,42 @@ function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter)
     for (let i = 0, len = durableKeys.length; i < len; i += 1) {
         const key = durableKeys[i];
         const durableRecord = durableRecords[key];
-        const { expiration, data } = durableRecord;
+        if (isDeprecatedDurableStoreEntry(durableRecord)) {
+            // had the old shape, skip reviving this entry.
+            hadUnexpectedShape = true;
+            continue;
+        }
+        const { metadata, data } = durableRecord;
         if (data === undefined) {
             // if unexpected data skip reviving
             hadUnexpectedShape = true;
             continue;
         }
-        if (expiration !== undefined) {
-            const { fresh, stale } = expiration;
-            if (fresh === undefined || stale === undefined) {
+        if (metadata !== undefined) {
+            const { expirationTimestamp, staleTimestamp } = metadata;
+            if (expirationTimestamp === undefined || staleTimestamp === undefined) {
                 // if unexpected expiration data skip reviving
                 hadUnexpectedShape = true;
                 continue;
             }
             // if past stale TTL then don't revive
-            if (stale < now) {
+            if (staleTimestamp < now) {
                 continue;
             }
             // We don't want to revive a cached value if it's an error and it's
-            // fresh TTL is expired, otherwise we would never hit the network
+            // expirationTimestamp TTL is expired, otherwise we would never hit the network
             // during resolveSnapshot or rebuildSnapshot in the makeOffline
             // environment because the way the Reader works.
             // If a StoreEntry is an error, the Reader will return UnfulfilledSnapshot
             // if stale TTL is expired.  But it will return ErrorSnapshot (instead of
-            // StaleSnapshot) if fresh TTL is expired (but stale TTL isn't).
+            // StaleSnapshot) if expirationTimestamp TTL is expired (but stale TTL isn't).
             // In makeOffline environment the stale TTL is maxed out so Reader
             // will always return ErrorSnapshot.
-            if (isStoreEntryExpiredAndError(data, fresh, now)) {
+            if (isStoreEntryExpiredAndError(data, expirationTimestamp, now)) {
                 continue;
             }
-            // call base storeSetExpiration so we don't add the key to pendingWriters
-            environment.storeSetExpiration(key, fresh, stale);
+            // call base publishStoreMetadata so we don't add the key to pendingWriters
+            environment.publishStoreMetadata(key, metadata);
         }
         if (isStoreEntryError(data)) {
             // freeze errors on way into L1
@@ -375,7 +387,7 @@ function reviveSnapshot(environment, durableStore, pendingWriter, unavailableSna
         // now that we have revived the missingLinks
         const snapshot = baseSnapshot === undefined
             ? environment.storeLookup(unavailableSnapshot.select, environment.createSnapshot, unavailableSnapshot.refresh)
-            : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreRecordExpirations(), environment.getStoreRedirectKeys(), () => { });
+            : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreMetadataMap(), environment.getStoreRedirectKeys(), () => { });
         // if snapshot is pending then some other in-flight refresh will broadcast
         // later
         if (snapshot.state === 'Pending') {
@@ -518,6 +530,12 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
         pendingWriter.addPendingWrite(recordId);
         environment.storeSetExpiration(recordId, expiration, staleExpiration);
     };
+    const publishStoreMetadata = function (recordId, storeMetadata) {
+        validateNotDisposed();
+        // mark this as pending write since we need to re-write with updated metadata values
+        pendingWriter.addPendingWrite(recordId);
+        environment.publishStoreMetadata(recordId, storeMetadata);
+    };
     const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
         // don't await the DS write - DS implementation will take care of R/W
         // synchronization
@@ -552,10 +570,10 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
         }
         return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refresh, durableStoreErrorHandler);
     };
-    const rebuildSnapshot = function (snapshot, records, recordExpirations, redirects, onAsyncRebuild) {
+    const rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
         validateNotDisposed();
         // try rebuilding from memory
-        const rebuilt = environment.rebuildSnapshot(snapshot, records, recordExpirations, redirects, onAsyncRebuild);
+        const rebuilt = environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, onAsyncRebuild);
         // only try reviving from durable store if snapshot is unfulfilled
         if (rebuilt.state !== 'Unfulfilled') {
             return rebuilt;
@@ -616,6 +634,7 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
     };
     return create(environment, {
         storeSetExpiration: { value: storeSetExpiration },
+        publishStoreMetadata: { value: publishStoreMetadata },
         storeBroadcast: { value: storeBroadcast },
         storeReset: { value: storeReset },
         resolveSnapshot: { value: resolveSnapshot },
@@ -662,6 +681,12 @@ function makeOffline(environment) {
     const setExpiration = function (recordId, expiration, _staleExpiration) {
         environment.storeSetExpiration(recordId, expiration, Number.MAX_SAFE_INTEGER);
     };
+    const publishStoreMetadata = function (recordId, storeMetadata) {
+        environment.publishStoreMetadata(recordId, {
+            ...storeMetadata,
+            staleTimestamp: Number.MAX_SAFE_INTEGER,
+        });
+    };
     return create(environment, {
         storeLookup: { value: storeLookup },
         snapshotAvailable: {
@@ -670,6 +695,9 @@ function makeOffline(environment) {
         storeSetExpiration: {
             value: setExpiration,
         },
+        publishStoreMetadata: {
+            value: publishStoreMetadata,
+        },
     });
 }
 

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

@@ -1,8 +1,24 @@
 /**
  * Contains store entry data along with any metadata for that entry that needs
  * to be persisted to durable storage
+ *
+ * IMPORTANT: if you update this interface, you must also create a
+ * deprecated interface, and check for durable store entries of this
+ * type in isDeprecatedDurableStoreEntry so that revive discards
+ * invalid entries.
  */
 export interface DurableStoreEntry<T = unknown> {
+    data: T;
+    metadata?: {
+        ingestionTimestamp: number;
+        expirationTimestamp: number;
+        staleTimestamp?: number;
+        namespace: string;
+        representationName: string;
+    };
+}
+export declare function isDeprecatedDurableStoreEntry(durableRecord: unknown): boolean;
+export interface DeprecatedDurableStoreEntry1<T = unknown> {
     data: T;
     expiration?: {
         fresh: number;

package/dist/umd/es2018/environments.js

@@ -4,6 +4,13 @@
     (global = global || self, factory(global.luvioEnvironments = {}));
 }(this, (function (exports) { 'use strict';
 
+    function isDeprecatedDurableStoreEntry(durableRecord) {
+        if (durableRecord.expiration !== undefined) {
+            return true;
+        }
+        // Add more deprecated shape checks here
+        return false;
+    }
     (function (DurableStoreOperationType) {
         DurableStoreOperationType["SetEntries"] = "setEntries";
         DurableStoreOperationType["EvictEntries"] = "evictEntries";
@@ -67,7 +74,7 @@
             flushPendingWritesToDurableStore: function (environment, durableStore, durableStoreErrorHandler) {
                 const durableRecords = create({});
                 const records = environment.getStoreRecords();
-                const expirations = environment.getStoreRecordExpirations();
+                const storeMetadataMap = environment.getStoreMetadataMap();
                 const keys$1 = keys(pendingDurableWrites);
                 for (let i = 0, len = keys$1.length; i < len; i += 1) {
                     const key = keys$1[i];
@@ -76,12 +83,12 @@
                     if (record === undefined) {
                         continue;
                     }
-                    const ttl = expirations[key];
+                    const recordMetadata = storeMetadataMap[key];
                     durableRecords[key] = {
                         // make copy of record b/c evict is coming
                         // NOTE: only spread copy if an array or object
                         data: copy(record),
-                        expiration: ttl,
+                        metadata: recordMetadata,
                     };
                     // remove record from L1 cache while we are on the synchronous path
                     // because we do not want some other code attempting to use the
@@ -255,8 +262,8 @@
     function isStoreEntryError(storeRecord) {
         return storeRecord.__type === 'error';
     }
-    function isStoreEntryExpiredAndError(storeRecord, fresh, now) {
-        return isStoreEntryError(storeRecord) && fresh < now;
+    function isStoreEntryExpiredAndError(storeRecord, expirationTimestamp, now) {
+        return isStoreEntryError(storeRecord) && expirationTimestamp < now;
     }
     function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter) {
         const revivedKeys = create(null);
@@ -273,37 +280,42 @@
         for (let i = 0, len = durableKeys.length; i < len; i += 1) {
             const key = durableKeys[i];
             const durableRecord = durableRecords[key];
-            const { expiration, data } = durableRecord;
+            if (isDeprecatedDurableStoreEntry(durableRecord)) {
+                // had the old shape, skip reviving this entry.
+                hadUnexpectedShape = true;
+                continue;
+            }
+            const { metadata, data } = durableRecord;
             if (data === undefined) {
                 // if unexpected data skip reviving
                 hadUnexpectedShape = true;
                 continue;
             }
-            if (expiration !== undefined) {
-                const { fresh, stale } = expiration;
-                if (fresh === undefined || stale === undefined) {
+            if (metadata !== undefined) {
+                const { expirationTimestamp, staleTimestamp } = metadata;
+                if (expirationTimestamp === undefined || staleTimestamp === undefined) {
                     // if unexpected expiration data skip reviving
                     hadUnexpectedShape = true;
                     continue;
                 }
                 // if past stale TTL then don't revive
-                if (stale < now) {
+                if (staleTimestamp < now) {
                     continue;
                 }
                 // We don't want to revive a cached value if it's an error and it's
-                // fresh TTL is expired, otherwise we would never hit the network
+                // expirationTimestamp TTL is expired, otherwise we would never hit the network
                 // during resolveSnapshot or rebuildSnapshot in the makeOffline
                 // environment because the way the Reader works.
                 // If a StoreEntry is an error, the Reader will return UnfulfilledSnapshot
                 // if stale TTL is expired.  But it will return ErrorSnapshot (instead of
-                // StaleSnapshot) if fresh TTL is expired (but stale TTL isn't).
+                // StaleSnapshot) if expirationTimestamp TTL is expired (but stale TTL isn't).
                 // In makeOffline environment the stale TTL is maxed out so Reader
                 // will always return ErrorSnapshot.
-                if (isStoreEntryExpiredAndError(data, fresh, now)) {
+                if (isStoreEntryExpiredAndError(data, expirationTimestamp, now)) {
                     continue;
                 }
-                // call base storeSetExpiration so we don't add the key to pendingWriters
-                environment.storeSetExpiration(key, fresh, stale);
+                // call base publishStoreMetadata so we don't add the key to pendingWriters
+                environment.publishStoreMetadata(key, metadata);
             }
             if (isStoreEntryError(data)) {
                 // freeze errors on way into L1
@@ -380,7 +392,7 @@
             // now that we have revived the missingLinks
             const snapshot = baseSnapshot === undefined
                 ? environment.storeLookup(unavailableSnapshot.select, environment.createSnapshot, unavailableSnapshot.refresh)
-                : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreRecordExpirations(), environment.getStoreRedirectKeys(), () => { });
+                : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreMetadataMap(), environment.getStoreRedirectKeys(), () => { });
             // if snapshot is pending then some other in-flight refresh will broadcast
             // later
             if (snapshot.state === 'Pending') {
@@ -523,6 +535,12 @@
             pendingWriter.addPendingWrite(recordId);
             environment.storeSetExpiration(recordId, expiration, staleExpiration);
         };
+        const publishStoreMetadata = function (recordId, storeMetadata) {
+            validateNotDisposed();
+            // mark this as pending write since we need to re-write with updated metadata values
+            pendingWriter.addPendingWrite(recordId);
+            environment.publishStoreMetadata(recordId, storeMetadata);
+        };
         const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
             // don't await the DS write - DS implementation will take care of R/W
             // synchronization
@@ -557,10 +575,10 @@
             }
             return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refresh, durableStoreErrorHandler);
         };
-        const rebuildSnapshot = function (snapshot, records, recordExpirations, redirects, onAsyncRebuild) {
+        const rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
-            const rebuilt = environment.rebuildSnapshot(snapshot, records, recordExpirations, redirects, onAsyncRebuild);
+            const rebuilt = environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, onAsyncRebuild);
             // only try reviving from durable store if snapshot is unfulfilled
             if (rebuilt.state !== 'Unfulfilled') {
                 return rebuilt;
@@ -621,6 +639,7 @@
         };
         return create(environment, {
             storeSetExpiration: { value: storeSetExpiration },
+            publishStoreMetadata: { value: publishStoreMetadata },
             storeBroadcast: { value: storeBroadcast },
             storeReset: { value: storeReset },
             resolveSnapshot: { value: resolveSnapshot },
@@ -667,6 +686,12 @@
         const setExpiration = function (recordId, expiration, _staleExpiration) {
             environment.storeSetExpiration(recordId, expiration, Number.MAX_SAFE_INTEGER);
         };
+        const publishStoreMetadata = function (recordId, storeMetadata) {
+            environment.publishStoreMetadata(recordId, {
+                ...storeMetadata,
+                staleTimestamp: Number.MAX_SAFE_INTEGER,
+            });
+        };
         return create(environment, {
             storeLookup: { value: storeLookup },
             snapshotAvailable: {
@@ -675,6 +700,9 @@
             storeSetExpiration: {
                 value: setExpiration,
             },
+            publishStoreMetadata: {
+                value: publishStoreMetadata,
+            },
         });
     }
 

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

@@ -1,8 +1,24 @@
 /**
  * Contains store entry data along with any metadata for that entry that needs
  * to be persisted to durable storage
+ *
+ * IMPORTANT: if you update this interface, you must also create a
+ * deprecated interface, and check for durable store entries of this
+ * type in isDeprecatedDurableStoreEntry so that revive discards
+ * invalid entries.
  */
 export interface DurableStoreEntry<T = unknown> {
+    data: T;
+    metadata?: {
+        ingestionTimestamp: number;
+        expirationTimestamp: number;
+        staleTimestamp?: number;
+        namespace: string;
+        representationName: string;
+    };
+}
+export declare function isDeprecatedDurableStoreEntry(durableRecord: unknown): boolean;
+export interface DeprecatedDurableStoreEntry1<T = unknown> {
     data: T;
     expiration?: {
         fresh: number;

package/dist/umd/es5/environments.js

@@ -4,6 +4,13 @@
     (global = global || self, factory(global.luvioEnvironments = {}));
 }(this, (function (exports) { 'use strict';
 
+    function isDeprecatedDurableStoreEntry(durableRecord) {
+        if (durableRecord.expiration !== undefined) {
+            return true;
+        }
+        // Add more deprecated shape checks here
+        return false;
+    }
     (function (DurableStoreOperationType) {
         DurableStoreOperationType["SetEntries"] = "setEntries";
         DurableStoreOperationType["EvictEntries"] = "evictEntries";
@@ -102,7 +109,7 @@
             flushPendingWritesToDurableStore: function (environment, durableStore, durableStoreErrorHandler) {
                 var durableRecords = create({});
                 var records = environment.getStoreRecords();
-                var expirations = environment.getStoreRecordExpirations();
+                var storeMetadataMap = environment.getStoreMetadataMap();
                 var keys$1 = keys(pendingDurableWrites);
                 for (var i = 0, len = keys$1.length; i < len; i += 1) {
                     var key = keys$1[i];
@@ -111,12 +118,12 @@
                     if (record === undefined) {
                         continue;
                     }
-                    var ttl = expirations[key];
+                    var recordMetadata = storeMetadataMap[key];
                     durableRecords[key] = {
                         // make copy of record b/c evict is coming
                         // NOTE: only spread copy if an array or object
                         data: copy(record),
-                        expiration: ttl,
+                        metadata: recordMetadata,
                     };
                     // remove record from L1 cache while we are on the synchronous path
                     // because we do not want some other code attempting to use the
@@ -281,8 +288,8 @@
     function isStoreEntryError(storeRecord) {
         return storeRecord.__type === 'error';
     }
-    function isStoreEntryExpiredAndError(storeRecord, fresh, now) {
-        return isStoreEntryError(storeRecord) && fresh < now;
+    function isStoreEntryExpiredAndError(storeRecord, expirationTimestamp, now) {
+        return isStoreEntryError(storeRecord) && expirationTimestamp < now;
     }
     function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter) {
         var revivedKeys = create(null);
@@ -299,37 +306,42 @@
         for (var i = 0, len = durableKeys.length; i < len; i += 1) {
             var key = durableKeys[i];
             var durableRecord = durableRecords[key];
-            var expiration = durableRecord.expiration, data = durableRecord.data;
+            if (isDeprecatedDurableStoreEntry(durableRecord)) {
+                // had the old shape, skip reviving this entry.
+                hadUnexpectedShape = true;
+                continue;
+            }
+            var metadata = durableRecord.metadata, data = durableRecord.data;
             if (data === undefined) {
                 // if unexpected data skip reviving
                 hadUnexpectedShape = true;
                 continue;
             }
-            if (expiration !== undefined) {
-                var fresh = expiration.fresh, stale = expiration.stale;
-                if (fresh === undefined || stale === undefined) {
+            if (metadata !== undefined) {
+                var expirationTimestamp = metadata.expirationTimestamp, staleTimestamp = metadata.staleTimestamp;
+                if (expirationTimestamp === undefined || staleTimestamp === undefined) {
                     // if unexpected expiration data skip reviving
                     hadUnexpectedShape = true;
                     continue;
                 }
                 // if past stale TTL then don't revive
-                if (stale < now) {
+                if (staleTimestamp < now) {
                     continue;
                 }
                 // We don't want to revive a cached value if it's an error and it's
-                // fresh TTL is expired, otherwise we would never hit the network
+                // expirationTimestamp TTL is expired, otherwise we would never hit the network
                 // during resolveSnapshot or rebuildSnapshot in the makeOffline
                 // environment because the way the Reader works.
                 // If a StoreEntry is an error, the Reader will return UnfulfilledSnapshot
                 // if stale TTL is expired.  But it will return ErrorSnapshot (instead of
-                // StaleSnapshot) if fresh TTL is expired (but stale TTL isn't).
+                // StaleSnapshot) if expirationTimestamp TTL is expired (but stale TTL isn't).
                 // In makeOffline environment the stale TTL is maxed out so Reader
                 // will always return ErrorSnapshot.
-                if (isStoreEntryExpiredAndError(data, fresh, now)) {
+                if (isStoreEntryExpiredAndError(data, expirationTimestamp, now)) {
                     continue;
                 }
-                // call base storeSetExpiration so we don't add the key to pendingWriters
-                environment.storeSetExpiration(key, fresh, stale);
+                // call base publishStoreMetadata so we don't add the key to pendingWriters
+                environment.publishStoreMetadata(key, metadata);
             }
             if (isStoreEntryError(data)) {
                 // freeze errors on way into L1
@@ -408,7 +420,7 @@
             // now that we have revived the missingLinks
             var snapshot = baseSnapshot === undefined
                 ? environment.storeLookup(unavailableSnapshot.select, environment.createSnapshot, unavailableSnapshot.refresh)
-                : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreRecordExpirations(), environment.getStoreRedirectKeys(), function () { });
+                : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreMetadataMap(), environment.getStoreRedirectKeys(), function () { });
             // if snapshot is pending then some other in-flight refresh will broadcast
             // later
             if (snapshot.state === 'Pending') {
@@ -553,6 +565,12 @@
             pendingWriter.addPendingWrite(recordId);
             environment.storeSetExpiration(recordId, expiration, staleExpiration);
         };
+        var publishStoreMetadata = function (recordId, storeMetadata) {
+            validateNotDisposed();
+            // mark this as pending write since we need to re-write with updated metadata values
+            pendingWriter.addPendingWrite(recordId);
+            environment.publishStoreMetadata(recordId, storeMetadata);
+        };
         var storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
             // don't await the DS write - DS implementation will take care of R/W
             // synchronization
@@ -587,10 +605,10 @@
             }
             return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refresh, durableStoreErrorHandler);
         };
-        var rebuildSnapshot = function (snapshot, records, recordExpirations, redirects, onAsyncRebuild) {
+        var rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
-            var rebuilt = environment.rebuildSnapshot(snapshot, records, recordExpirations, redirects, onAsyncRebuild);
+            var rebuilt = environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, onAsyncRebuild);
             // only try reviving from durable store if snapshot is unfulfilled
             if (rebuilt.state !== 'Unfulfilled') {
                 return rebuilt;
@@ -649,6 +667,7 @@
         };
         return create(environment, {
             storeSetExpiration: { value: storeSetExpiration },
+            publishStoreMetadata: { value: publishStoreMetadata },
             storeBroadcast: { value: storeBroadcast },
             storeReset: { value: storeReset },
             resolveSnapshot: { value: resolveSnapshot },
@@ -695,6 +714,9 @@
         var setExpiration = function (recordId, expiration, _staleExpiration) {
             environment.storeSetExpiration(recordId, expiration, Number.MAX_SAFE_INTEGER);
         };
+        var publishStoreMetadata = function (recordId, storeMetadata) {
+            environment.publishStoreMetadata(recordId, __assign(__assign({}, storeMetadata), { staleTimestamp: Number.MAX_SAFE_INTEGER }));
+        };
         return create(environment, {
             storeLookup: { value: storeLookup },
             snapshotAvailable: {
@@ -703,6 +725,9 @@
             storeSetExpiration: {
                 value: setExpiration,
             },
+            publishStoreMetadata: {
+                value: publishStoreMetadata,
+            },
         });
     }
 

package/package.json

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