failproofai 1.0.1-beta.1 → 1.0.2-beta.0

package/.next/standalone/node_modules/next/dist/server/use-cache/handlers.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", {
     getDevTieredCacheHandler: null,
     getPrivateCacheHandler: null,
     initializeCacheHandlers: null,
+    isBuiltInCacheHandler: null,
     isCustomCacheHandler: null,
     isMemoryCacheDisabled: null,
     setCacheHandler: null
@@ -38,6 +39,9 @@ _export(exports, {
     initializeCacheHandlers: function() {
         return initializeCacheHandlers;
     },
+    isBuiltInCacheHandler: function() {
+        return isBuiltInCacheHandler;
+    },
     isCustomCacheHandler: function() {
         return isCustomCacheHandler;
     },
@@ -57,6 +61,7 @@ const handlersSymbol = Symbol.for('@next/cache-handlers');
 const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
 const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
 const privateHandlerSymbol = Symbol.for('@next/cache-handlers-private');
+const builtInHandlersSymbol = Symbol.for('@next/cache-handlers-built-in');
 const devFrontHandlersSymbol = Symbol.for('@next/cache-handlers-dev-fronts');
 const devTieredHandlersSymbol = Symbol.for('@next/cache-handlers-dev-tiered');
 const memoryCacheDisabledSymbol = Symbol.for('@next/cache-handlers-memory-disabled');
@@ -80,6 +85,8 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
     debug == null ? void 0 : debug('initializing cache handlers');
     const handlersMap = new Map();
     reference[handlersMapSymbol] = handlersMap;
+    const builtInHandlers = new Set();
+    reference[builtInHandlersSymbol] = builtInHandlers;
     // In development, `cacheMaxMemorySize: 0` would make the built-in default
     // handler a no-op, so every reload would miss. Use a real in-memory size
     // instead so dev stays fast; the "use cache" wrapper forces a dynamic cache
@@ -95,6 +102,7 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
         } else {
             debug == null ? void 0 : debug('setting "default" cache handler from default');
             fallback = (0, _default.createDefaultCacheHandler)(builtInSize);
+            builtInHandlers.add(fallback);
         }
         handlersMap.set('default', fallback);
         if (reference[handlersSymbol].RemoteCache) {
@@ -106,6 +114,7 @@ function initializeCacheHandlers(cacheMaxMemorySize) {
         }
     } else {
         const handler = (0, _default.createDefaultCacheHandler)(builtInSize);
+        builtInHandlers.add(handler);
         debug == null ? void 0 : debug('setting "default" cache handler from default');
         handlersMap.set('default', handler);
         debug == null ? void 0 : debug('setting "remote" cache handler from default');
@@ -166,6 +175,11 @@ function isCustomCacheHandler(kind) {
     }
     return ((_reference_devFrontHandlersSymbol = reference[devFrontHandlersSymbol]) == null ? void 0 : _reference_devFrontHandlersSymbol.has(kind)) ?? false;
 }
+function isBuiltInCacheHandler(kind) {
+    var _reference_handlersMapSymbol, _reference_builtInHandlersSymbol;
+    const handler = (_reference_handlersMapSymbol = reference[handlersMapSymbol]) == null ? void 0 : _reference_handlersMapSymbol.get(kind);
+    return handler !== undefined && Boolean((_reference_builtInHandlersSymbol = reference[builtInHandlersSymbol]) == null ? void 0 : _reference_builtInHandlersSymbol.has(handler));
+}
 function getDevTieredCacheHandler(kind) {
     var _reference_devTieredHandlersSymbol;
     if (!process.env.__NEXT_DEV_SERVER) {

package/.next/standalone/node_modules/next/dist/server/use-cache/use-cache-probe-scheduler.js

@@ -48,7 +48,8 @@ function setupProbeScheduler(opts) {
                 rootParams: outerRequestStore.rootParams ?? {},
                 isDraftMode: workStore.isDraftMode ?? false,
                 isHmrRefresh: outerRequestStore.isHmrRefresh ?? false,
-                hmrRefreshHash: outerRequestStore.hmrRefreshHash
+                hmrRefreshHash: outerRequestStore.hmrRefreshHash,
+                requestStartTime: workStore.requestStartTime
             },
             timeoutMs: probeInternalTimeoutMs
         }).then((completed)=>{

package/.next/standalone/node_modules/next/dist/server/use-cache/use-cache-wrapper.js

@@ -111,17 +111,21 @@ function ignoreReject() {}
  * join while the leader streams. For 'prerender-dynamic' and errors, cleanup
  * is immediate.
  */ class ResolvableSharedCacheResult {
-    registerIn(map, key) {
+    registerIn(map, key, retentionMap) {
         map.set(key, this.deferred.promise);
         this.registrations.push({
             map,
-            key
+            key,
+            retentionMap
         });
     }
     resolve(result) {
         this.deferred.resolve(result);
         if (result.type === 'cached') {
-            result.entry.pendingMetadata.finally(this.cleanup.bind(this));
+            // Retain only an entry that collected successfully. A failed collection
+            // leaves metadata a later invocation cannot read, so it is dropped like
+            // any other failure and the next invocation regenerates.
+            result.entry.pendingMetadata.then(()=>this.cleanupAndRetain(), ()=>this.cleanup());
         } else {
             this.cleanup();
         }
@@ -135,11 +139,26 @@ function ignoreReject() {}
         this.deferred.reject(error);
         this.cleanup();
     }
-    cleanup() {
+    /**
+   * Drops the pending registrations, leaving nothing for a later invocation to
+   * join. Used when the invocation produced no entry that a later one could
+   * serve: an error has no value, and a 'prerender-dynamic' result is a hanging
+   * promise bound to the leader's render signal.
+   */ cleanup() {
         for (const { map, key } of this.registrations){
             map.delete(key);
         }
     }
+    /**
+   * Drops the pending registrations and moves the entry into the retention map
+   * where one was given, so a later invocation in the same request can reuse it
+   * instead of repeating the lookup and, on a miss, the work.
+   */ cleanupAndRetain() {
+        for (const { map, key, retentionMap } of this.registrations){
+            map.delete(key);
+            retentionMap == null ? void 0 : retentionMap.set(key, this.deferred.promise);
+        }
+    }
     constructor(){
         this.deferred = (0, _promisewithresolvers.createPromiseWithResolvers)();
         this.registrations = [];
@@ -306,6 +325,31 @@ function saveToResumeDataCache(resumeDataCache, serializedCacheKey, pendingCache
     resumeDataCache.cache.set(serializedCacheKey, rdcResult);
     debug == null ? void 0 : debug('Resume Data Cache entry saved by joiner', serializedCacheKey);
 }
+/**
+ * Completes a join onto another invocation's entry, whether that invocation is
+ * still filling or has already finished: forks the stream, saves to this
+ * invocation's RDC if the leader had none, and balances the cache signal read
+ * once the entry is fully collected.
+ */ function serveJoinedCacheEntry(sharedCacheEntry, serializedCacheKey, resumeDataCache, cacheContext, cacheSignal) {
+    const stream = sharedCacheEntry.fork();
+    // If the leader was nested inside another cache (no accessible RDC), it
+    // couldn't save to the RDC. This joiner may be top-level with an RDC, in
+    // which case it must save here; otherwise the RDC lookup during the final
+    // prerender will miss.
+    saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheEntry, resumeDataCache);
+    // End the cache signal read when the result is fully collected, not when the
+    // stream is available. A failed collection has no metadata to propagate but
+    // must still balance the read, so both settlements end it; leaving it open
+    // would stall a prerender waiting for its cache reads. The trailing .catch()
+    // covers propagation itself throwing after the rendering stream resolved.
+    sharedCacheEntry.pendingMetadata.then((metadata)=>{
+        cacheSignal == null ? void 0 : cacheSignal.endRead();
+        maybePropagateCacheEntryMetadata(cacheContext, metadata);
+    }, ()=>{
+        cacheSignal == null ? void 0 : cacheSignal.endRead();
+    }).catch(()=>{});
+    return stream;
+}
 function saveToCacheHandler(cacheHandler, workStore, id, cacheHandlerKeyBase, savedCacheResult, rootParams) {
     // Write the entry to the cache handler. With root params, this is a redirect
     // entry at the coarse key plus the actual entry at the specific key;
@@ -1621,7 +1665,8 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
             // tags. When a server action calls updateTag(), the re-render should see
             // fresh data instead of stale RDC data.
             if (rdcResult !== undefined) {
-                if (rdcResult.entry.tags.some((tag)=>isRecentlyRevalidatedTag(tag, workStore)) || implicitTags.some((tag)=>isRecentlyRevalidatedTag(tag, workStore))) {
+                const { timestamp } = rdcResult.entry;
+                if (rdcResult.entry.tags.some((tag)=>isRevalidatedAfter(tag, timestamp, workStore)) || implicitTags.some((tag)=>isRevalidatedAfter(tag, timestamp, workStore))) {
                     debug == null ? void 0 : debug('discarding RDC entry due to recently revalidated tags', serializedCacheKey);
                     rdcResult = undefined;
                 }
@@ -1936,33 +1981,44 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
     // doing redundant work. This also saves cache handler `get` calls which may
     // be HTTP round-trips for remote handlers.
     if (stream === undefined) {
-        var _workStore_pendingCacheInvocations;
-        const intraRequestPendingCacheInvocation = (_workStore_pendingCacheInvocations = workStore.pendingCacheInvocations) == null ? void 0 : _workStore_pendingCacheInvocations.get(serializedCacheKey);
-        if (intraRequestPendingCacheInvocation) {
+        var _workStore_pendingCacheInvocations, _workStore_completedCacheInvocations;
+        const pendingInvocation = (_workStore_pendingCacheInvocations = workStore.pendingCacheInvocations) == null ? void 0 : _workStore_pendingCacheInvocations.get(serializedCacheKey);
+        // A pending invocation is joined unconditionally: its fill is shared, so
+        // every joiner receives whatever that fill produces. A completed one is a
+        // stored entry instead, so it is only reused when the caller hasn't asked
+        // to bypass caches, and only if nothing has invalidated it since.
+        const completedInvocation = pendingInvocation === undefined && !shouldForceRevalidate(workStore, workUnitStore) ? (_workStore_completedCacheInvocations = workStore.completedCacheInvocations) == null ? void 0 : _workStore_completedCacheInvocations.get(serializedCacheKey) : undefined;
+        const joinedInvocation = pendingInvocation ?? completedInvocation;
+        if (joinedInvocation) {
             const cacheSignal = (0, _workunitasyncstorageexternal.getCacheSignal)(workUnitStore);
             cacheSignal == null ? void 0 : cacheSignal.beginRead();
-            debug == null ? void 0 : debug('joining pending intra-request invocation', serializedCacheKey);
-            const sharedCacheResult = await intraRequestPendingCacheInvocation;
+            debug == null ? void 0 : debug('joining intra-request invocation', serializedCacheKey);
+            const sharedCacheResult = await joinedInvocation;
             if (sharedCacheResult.type === 'prerender-dynamic') {
                 debug == null ? void 0 : debug('joined invocation is prerender-dynamic', serializedCacheKey);
                 cacheSignal == null ? void 0 : cacheSignal.endRead();
                 return sharedCacheResult.hangingPromise;
             }
-            debug == null ? void 0 : debug('joined invocation resolved with cached entry', serializedCacheKey);
-            stream = sharedCacheResult.entry.fork();
-            // If the leader was nested inside another cache (no accessible RDC), it
-            // couldn't save to the RDC. This joiner may be top-level with an RDC, in
-            // which case it must save here; otherwise the RDC lookup during the
-            // final prerender will miss.
-            saveSharedCacheEntryToResumeDataCache(serializedCacheKey, sharedCacheResult.entry, resumeDataCache);
-            // End the cache signal read when the result is fully collected, not when
-            // the stream is available. Fire-and-forget propagation runs in the same
-            // .then() callback. .catch() prevents unhandled rejection if collection
-            // fails after the rendering stream was already resolved.
-            sharedCacheResult.entry.pendingMetadata.then((metadata)=>{
+            // A completed entry may have been invalidated since it was produced, by
+            // an `updateTag()` in a server action earlier in this request. The
+            // implicit tags expiration is passed as 0 because it cannot apply to a
+            // retained entry: it is memoized for the request, so re-checking it
+            // against an unchanged entry timestamp only repeats the answer the leader
+            // already got.
+            const metadata = completedInvocation === undefined ? undefined : await sharedCacheResult.entry.pendingMetadata;
+            if (metadata !== undefined && shouldDiscardCacheEntry(metadata, workStore, workUnitStore, implicitTags, 0)) {
+                var _workStore_completedCacheInvocations1;
+                debug == null ? void 0 : debug('discarding completed invocation', serializedCacheKey);
+                (_workStore_completedCacheInvocations1 = workStore.completedCacheInvocations) == null ? void 0 : _workStore_completedCacheInvocations1.delete(serializedCacheKey);
+                // This can take the signal's count to zero. The leader path below opens
+                // a read again synchronously, before it awaits anything, which is what
+                // stops a prerender from concluding that every cache read has settled
+                // while a fill is still about to start.
                 cacheSignal == null ? void 0 : cacheSignal.endRead();
-                maybePropagateCacheEntryMetadata(cacheContext, metadata);
-            }).catch(()=>{});
+            } else {
+                debug == null ? void 0 : debug('joined invocation resolved with cached entry', serializedCacheKey);
+                stream = serveJoinedCacheEntry(sharedCacheResult.entry, serializedCacheKey, resumeDataCache, cacheContext, cacheSignal);
+            }
         }
     }
     // Leader path: no pending intra-request invocation found. Check for a
@@ -1971,7 +2027,14 @@ async function cache(kind, id, boundArgsLength, originalFn, args) {
         const resolvableSharedCacheResult = new ResolvableSharedCacheResult();
         debug == null ? void 0 : debug('registering as intra-request invocation leader', serializedCacheKey);
         const intraRequestPendingCacheInvocations = workStore.pendingCacheInvocations ??= new Map();
-        resolvableSharedCacheResult.registerIn(intraRequestPendingCacheInvocations, serializedCacheKey);
+        // Retain the completed entry for the rest of the request where a later
+        // invocation would otherwise repeat real work: private caches have no cache
+        // handler to fall back on in production, and a platform- or config-supplied
+        // handler may be remote, so a second `get` can be a round trip. A built-in
+        // handler read is a map lookup, so retaining its entries would hold a
+        // forked stream buffer for nothing.
+        const completedCacheInvocations = isPrivate || !(0, _handlers.isBuiltInCacheHandler)(kind) ? workStore.completedCacheInvocations ??= new Map() : undefined;
+        resolvableSharedCacheResult.registerIn(intraRequestPendingCacheInvocations, serializedCacheKey, completedCacheInvocations);
         // Cross-request deduplication lets concurrent requests for the same key
         // share a single fill. Private caches are skipped in production, where they
         // hold request-specific data that must not be shared across requests. In
@@ -2505,20 +2568,26 @@ function shouldDiscardCacheEntry(entry, workStore, workUnitStore, implicitTags,
     }
     // If the cache entry contains revalidated tags that the cache handler might
     // not know about yet, we need to discard it.
-    if (entry.tags.some((tag)=>isRecentlyRevalidatedTag(tag, workStore))) {
+    if (entry.tags.some((tag)=>isRevalidatedAfter(tag, entry.timestamp, workStore))) {
         return true;
     }
     // Finally, if any of the implicit tags have been revalidated recently, we
     // also need to discard the cache entry.
-    if (implicitTags.some((tag)=>isRecentlyRevalidatedTag(tag, workStore))) {
+    if (implicitTags.some((tag)=>isRevalidatedAfter(tag, entry.timestamp, workStore))) {
         return true;
     }
     return false;
 }
-function isRecentlyRevalidatedTag(tag, workStore) {
-    const { previouslyRevalidatedTags, pendingRevalidatedTags } = workStore;
+/**
+ * Whether `tag` was revalidated after an entry created at `entryTimestamp`,
+ * which makes that entry stale. An entry produced after the revalidation
+ * already reflects it and is still usable.
+ */ function isRevalidatedAfter(tag, entryTimestamp, workStore) {
+    const { previouslyRevalidatedTags, pendingRevalidatedTags, requestStartTime } = workStore;
     // Was the tag previously revalidated (e.g. by a redirecting server action)?
-    if (previouslyRevalidatedTags.includes(tag)) {
+    // That happened in an earlier request and carries no timestamp of its own, so
+    // it counts as having happened when this request started.
+    if (entryTimestamp <= requestStartTime && previouslyRevalidatedTags.includes(tag)) {
         debug == null ? void 0 : debug('tag', tag, 'was previously revalidated');
         return true;
     }
@@ -2526,7 +2595,7 @@ function isRecentlyRevalidatedTag(tag, workStore) {
     // In this case the revalidation might not have been fully propagated by a
     // remote cache handler yet, so we read it from the pending tags in the work
     // store.
-    if (pendingRevalidatedTags == null ? void 0 : pendingRevalidatedTags.some((item)=>item.tag === tag)) {
+    if (pendingRevalidatedTags == null ? void 0 : pendingRevalidatedTags.some((item)=>item.tag === tag && item.revalidatedAt > entryTimestamp)) {
         debug == null ? void 0 : debug('tag', tag, 'was just revalidated');
         return true;
     }

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/adapters/headers.js

@@ -34,6 +34,66 @@ class ReadonlyHeadersError extends Error {
         throw new ReadonlyHeadersError();
     }
 }
+/**
+ * Builds the read methods for a sealed view that exposes all of `target`.
+ */ function createPassThroughMethods(target, sealed) {
+    return {
+        get: target.get.bind(target),
+        has: target.has.bind(target),
+        getSetCookie: target.getSetCookie.bind(target),
+        keys: target.keys.bind(target),
+        values: target.values.bind(target),
+        entries: target.entries.bind(target),
+        [Symbol.iterator]: target[Symbol.iterator].bind(target),
+        // The native method passes the unsealed target as the callback's `parent`
+        // argument. That is a mutable handle on the underlying headers. Pass the
+        // sealed view instead.
+        forEach (callbackfn, thisArg) {
+            for (const [name, value] of target.entries()){
+                callbackfn.call(thisArg, value, name, sealed);
+            }
+        }
+    };
+}
+/**
+ * Builds the read methods for a sealed view that omits the header names matched
+ * by `isHidden`.
+ */ function createHidingMethods(target, sealed, isHidden) {
+    function* entries() {
+        for (const entry of target.entries()){
+            if (!isHidden(entry[0])) {
+                yield entry;
+            }
+        }
+    }
+    return {
+        entries,
+        [Symbol.iterator]: entries,
+        get: (name)=>isHidden(name) ? null : target.get(name),
+        has: (name)=>isHidden(name) ? false : target.has(name),
+        getSetCookie: ()=>isHidden('set-cookie') ? [] : target.getSetCookie(),
+        *keys () {
+            for (const name of target.keys()){
+                if (!isHidden(name)) {
+                    yield name;
+                }
+            }
+        },
+        *values () {
+            for (const [, value] of entries()){
+                yield value;
+            }
+        },
+        // The native method passes the unsealed target as the callback's `parent`
+        // argument. That is a mutable handle on the underlying headers. Pass the
+        // sealed view instead.
+        forEach (callbackfn, thisArg) {
+            for (const [name, value] of entries()){
+                callbackfn.call(thisArg, value, name, sealed);
+            }
+        }
+    };
+}
 class HeadersAdapter extends Headers {
     constructor(headers){
         // We've already overridden the methods that would be called, so we're just
@@ -98,19 +158,45 @@ class HeadersAdapter extends Headers {
     /**
    * Seals a Headers instance to prevent modification by throwing an error when
    * any mutating method is called.
-   */ static seal(headers) {
-        return new Proxy(headers, {
+   *
+   * The sealed view stays live. Later writes to `headers` remain visible
+   * through it.
+   *
+   * `hidden` omits the given header names from every read operation (`get`,
+   * `has`, `getSetCookie`, `forEach`, and iteration). The names must be
+   * lowercase. The underlying headers are neither copied nor mutated, so hidden
+   * headers remain available to the framework.
+   */ static seal(headers, hidden) {
+        const isHidden = hidden && hidden.size > 0 ? (name)=>hidden.has(name.toLowerCase()) : null;
+        // The methods are built once per sealed view and reused, so repeated access
+        // returns the same function instead of a fresh closure. They are assigned
+        // after the proxy exists because `forEach` hands the proxy to its callback.
+        // Creating the proxy runs no trap, so nothing can read them before then.
+        let methods;
+        const sealed = new Proxy(headers, {
             get (target, prop, receiver) {
                 switch(prop){
                     case 'append':
                     case 'delete':
                     case 'set':
                         return ReadonlyHeadersError.callable;
+                    case Symbol.iterator:
+                        return methods[Symbol.iterator];
+                    case 'get':
+                    case 'has':
+                    case 'getSetCookie':
+                    case 'keys':
+                    case 'values':
+                    case 'entries':
+                    case 'forEach':
+                        return methods[prop];
                     default:
                         return _reflect.ReflectAdapter.get(target, prop, receiver);
                 }
             }
         });
+        methods = isHidden ? createHidingMethods(headers, sealed, isHidden) : createPassThroughMethods(headers, sealed);
+        return sealed;
     }
     /**
    * @param headers

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/revalidate.js

@@ -37,7 +37,7 @@ const _hooksservercontext = require("../../../client/components/hooks-server-con
 const _invarianterror = require("../../../shared/lib/invariant-error");
 const _actionrevalidationkind = require("../../../shared/lib/action-revalidation-kind");
 const _removetrailingslash = require("../../../shared/lib/router/utils/remove-trailing-slash");
-const _encodecachetag = require("../../lib/encode-cache-tag");
+const _encodeheadersafe = require("../../lib/encode-header-safe");
 const _cachelifeprofile = require("../../use-cache/cache-life-profile");
 function revalidateTag(tag, profile) {
     if (!profile) {
@@ -48,7 +48,7 @@ function revalidateTag(tag, profile) {
         });
     }
     return revalidate([
-        (0, _encodecachetag.encodeCacheTag)(tag)
+        (0, _encodeheadersafe.encodeHeaderSafe)(tag)
     ], `revalidateTag ${tag}`, profile);
 }
 function updateTag(tag) {
@@ -64,7 +64,7 @@ function updateTag(tag) {
     }
     // updateTag uses immediate expiration (no profile) without deprecation warning
     return revalidate([
-        (0, _encodecachetag.encodeCacheTag)(tag)
+        (0, _encodeheadersafe.encodeHeaderSafe)(tag)
     ], `updateTag ${tag}`, undefined);
 }
 function refresh() {
@@ -88,7 +88,7 @@ function revalidatePath(originalPath, type) {
         console.warn(`Warning: revalidatePath received "${originalPath}" which exceeded max length of ${_constants.NEXT_CACHE_SOFT_TAG_MAX_LENGTH}. See more info here https://nextjs.org/docs/app/api-reference/functions/revalidatePath`);
         return;
     }
-    let normalizedPath = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${(0, _encodecachetag.encodeCacheTag)((0, _removetrailingslash.removeTrailingSlash)(originalPath))}`;
+    let normalizedPath = `${_constants.NEXT_CACHE_IMPLICIT_TAG_ID}${(0, _encodeheadersafe.encodeHeaderSafe)((0, _removetrailingslash.removeTrailingSlash)(originalPath))}`;
     if (type) {
         normalizedPath += `${normalizedPath.endsWith('/') ? '' : '/'}${type}`;
     } else if ((0, _utils.isDynamicRoute)(originalPath)) {
@@ -187,6 +187,7 @@ function revalidate(tags, expression, profile) {
     if (!store.pendingRevalidatedTags) {
         store.pendingRevalidatedTags = [];
     }
+    const revalidatedAt = performance.timeOrigin + performance.now();
     for (const tag of tags){
         const existingIndex = store.pendingRevalidatedTags.findIndex((item)=>{
             if (item.tag !== tag) return false;
@@ -202,8 +203,14 @@ function revalidate(tags, expression, profile) {
         if (existingIndex === -1) {
             store.pendingRevalidatedTags.push({
                 tag,
-                profile
+                profile,
+                revalidatedAt
             });
+        } else {
+            // Revalidating a tag again invalidates everything produced up to now, so
+            // the latest revalidation is the one that decides which entries are
+            // stale.
+            store.pendingRevalidatedTags[existingIndex].revalidatedAt = revalidatedAt;
         }
     }
     // if profile is provided and this is a stale-while-revalidate

package/.next/standalone/node_modules/next/dist/server/web/spec-extension/unstable-cache.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "unstable_cache", {
 });
 const _constants = require("../../../lib/constants");
 const _patchfetch = require("../../lib/patch-fetch");
+const _encodeheadersafe = require("../../lib/encode-header-safe");
 const _workasyncstorageexternal = require("../../app-render/work-async-storage.external");
 const _workunitasyncstorageexternal = require("../../app-render/work-unit-async-storage.external");
 const _responsecache = require("../../response-cache");
@@ -84,7 +85,18 @@ function unstable_cache(cb, keyParts, options = {}) {
             const invocationKey = `${fixedKey}-${JSON.stringify(args)}`;
             const cacheKey = await incrementalCache.generateSimpleCacheKey(invocationKey);
             // $urlWithPath,$sortedQueryStringKeys,$hashOfEveryThingElse
-            const fetchUrl = `unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`;
+            //
+            // A cache implementation may serialize this name into an HTTP request
+            // header, so it is encoded here. Both parts can carry a character above
+            // U+00FF: the search parameters are decoded, and a JavaScript identifier
+            // may hold one. The character class leaves the separating spaces and the
+            // URL punctuation untouched, so the shape above is preserved.
+            //
+            // `toWellFormed` replaces lone surrogates, which `cb.name` can hold and
+            // which `encodeURIComponent` rejects. The name identifies the call for
+            // debug metrics, so a replacement character is an acceptable trade for
+            // not failing the render.
+            const fetchUrl = (0, _encodeheadersafe.encodeHeaderSafe)(`unstable_cache ${fetchUrlPrefix} ${cb.name ? ` ${cb.name}` : cacheKey}`.toWellFormed());
             const fetchIdx = (workStore ? workStore.nextFetchId : noStoreFetchIdx) ?? 1;
             const implicitTags = workUnitStore == null ? void 0 : workUnitStore.implicitTags;
             const innerCacheStore = {

package/.next/standalone/node_modules/next/dist/telemetry/anonymous-meta.js

@@ -82,7 +82,7 @@ async function getAnonymousMeta() {
         isWsl: _iswsl.default,
         isCI: _ciinfo.isCI,
         ciName: _ciinfo.isCI && _ciinfo.name || null,
-        nextVersion: "16.3.0",
+        nextVersion: "16.3.1",
         agentName: await (0, _agentname.getAgentName)()
     };
     return traits;

package/.next/standalone/node_modules/next/dist/telemetry/events/swc-load-failure.js

@@ -38,7 +38,7 @@ async function eventSwcLoadFailure(event) {
     telemetry.record({
         eventName: EVENT_PLUGIN_PRESENT,
         payload: {
-            nextVersion: "16.3.0",
+            nextVersion: "16.3.1",
             glibcVersion,
             installedSwcPackages,
             arch: process.arch,

package/.next/standalone/node_modules/next/dist/telemetry/events/version.js

@@ -12,12 +12,12 @@ const EVENT_VERSION = 'NEXT_CLI_SESSION_STARTED';
 function eventCliSession(nextConfig, event) {
     var _nextConfig_experimental, _nextConfig_experimental_staleTimes, _nextConfig_experimental_staleTimes1, _nextConfig_reactCompiler, _nextConfig_reactCompiler1;
     // This should be an invariant, if it fails our build tooling is broken.
-    if (typeof "16.3.0" !== 'string') {
+    if (typeof "16.3.1" !== 'string') {
         return [];
     }
     const { images, i18n } = nextConfig || {};
     const payload = {
-        nextVersion: "16.3.0",
+        nextVersion: "16.3.1",
         nodeVersion: process.version,
         cliCommand: event.cliCommand,
         isSrcDir: event.isSrcDir,

package/.next/standalone/node_modules/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next",
-  "version": "16.3.0",
+  "version": "16.3.1",
   "description": "The React Framework",
   "main": "./dist/server/next.js",
   "license": "MIT",
@@ -81,8 +81,8 @@
     "next": "./dist/bin/next"
   },
   "dependencies": {
-    "@next/env": "16.3.0",
-    "@swc/helpers": "0.5.15",
+    "@next/env": "16.3.1",
+    "@swc/helpers": "0.5.23",
     "baseline-browser-mapping": "^2.9.19",
     "caniuse-lite": "^1.0.30001579",
     "postcss": "8.5.23",
@@ -112,14 +112,14 @@
   },
   "optionalDependencies": {
     "sharp": "^0.35.3",
-    "@next/swc-darwin-arm64": "16.3.0",
-    "@next/swc-darwin-x64": "16.3.0",
-    "@next/swc-linux-arm64-gnu": "16.3.0",
-    "@next/swc-linux-arm64-musl": "16.3.0",
-    "@next/swc-linux-x64-gnu": "16.3.0",
-    "@next/swc-linux-x64-musl": "16.3.0",
-    "@next/swc-win32-arm64-msvc": "16.3.0",
-    "@next/swc-win32-x64-msvc": "16.3.0"
+    "@next/swc-darwin-arm64": "16.3.1",
+    "@next/swc-darwin-x64": "16.3.1",
+    "@next/swc-linux-arm64-gnu": "16.3.1",
+    "@next/swc-linux-arm64-musl": "16.3.1",
+    "@next/swc-linux-x64-gnu": "16.3.1",
+    "@next/swc-linux-x64-musl": "16.3.1",
+    "@next/swc-win32-arm64-msvc": "16.3.1",
+    "@next/swc-win32-x64-msvc": "16.3.1"
   },
   "keywords": [
     "react",