failproofai 1.0.1-beta.1 → 1.0.1

package/.next/standalone/node_modules/next/dist/client/components/segment-cache/scheduler.js

@@ -82,12 +82,26 @@ function startRevalidationCooldown() {
     }, REVALIDATION_COOLDOWN_MS);
 }
 function schedulePrefetchTask(key, treeAtTimeOfPrefetch, fetchStrategy, priority, onInvalidate, navigationLockPrefetch) {
+    // Bind the task to the segment cache map that is active right now: the
+    // shared map, unless the Instant Navigation Testing lock is held, in which
+    // case the task gets the lock scope's private map. This is the single
+    // place work is bound to a map based on lock state — everything downstream
+    // receives the map explicitly. See `segmentCacheMap` in cache.ts.
+    let taskSegmentCacheMap = _cache.segmentCacheMap;
+    if (process.env.__NEXT_EXPOSE_TESTING_API) {
+        const { getNavigationLockSegmentCacheMap } = require('./navigation-testing-lock');
+        const lockMap = getNavigationLockSegmentCacheMap();
+        if (lockMap !== null) {
+            taskSegmentCacheMap = lockMap;
+        }
+    }
     // Spawn a new prefetch task
     const task = {
         key,
         treeAtTimeOfPrefetch,
         routeCacheVersion: (0, _cache.getCurrentRouteCacheVersion)(),
         segmentCacheVersion: (0, _cache.getCurrentSegmentCacheVersion)(),
+        segmentCacheMap: taskSegmentCacheMap,
         priority,
         phase: 2,
         hasBackgroundWork: false,
@@ -345,20 +359,14 @@ function processQueueInMicrotask() {
                     // once-guarded — in particular, the navigation-lock release below
                     // must not fire twice (hence the nulling).
                     if (process.env.__NEXT_EXPOSE_TESTING_API && task._navigationLockPrefetch != null) {
-                        // The scheduler has spawned every request for this locked-navigation
-                        // prefetch, so release its "still spawning" reference. The prefetch's
-                        // promise (awaited by `ensurePrefetchThenNavigate`) resolves once the
-                        // count reaches 0 — i.e. every spawned entry has also fulfilled, so
-                        // the navigation reads present data rather than a still-in-flight
-                        // entry. If everything already fulfilled, it resolves synchronously.
-                        //
-                        // TODO: Now that a task only completes after a full pass observes
-                        // every segment response it spawned or found in flight, the
-                        // navigation-testing lock's per-entry ref counting (pendingCount /
-                        // trackNavigationLockPrefetchEntry) is redundant — a single resolve
-                        // fired here would suffice.
-                        const { finishNavigationLockPrefetchSpawning } = require('./navigation-testing-lock');
-                        finishNavigationLockPrefetchSpawning(task._navigationLockPrefetch);
+                        // This locked-navigation prefetch is complete: the final pass
+                        // observed every segment response it cares about, so the data the
+                        // navigation will read has settled. Resolve the prefetch's
+                        // promise (awaited by `ensurePrefetchThenNavigate`) so the
+                        // navigation proceeds against present data rather than a
+                        // still-in-flight entry.
+                        const { resolveNavigationLockPrefetch } = require('./navigation-testing-lock');
+                        resolveNavigationLockPrefetch(task._navigationLockPrefetch);
                         // Release at most once per task: a stale registration from an
                         // earlier pass can re-ping a completed task (see above), so it can
                         // pass through here again.
@@ -425,7 +433,7 @@ function pingRoute(now, task) {
                 {
                     if (background(task)) {
                         routeWithoutSearch.status = _cache.EntryStatus.Pending;
-                        spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(routeWithoutSearch, keyWithoutSearch));
+                        spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(routeWithoutSearch, keyWithoutSearch, task.segmentCacheMap));
                     }
                     break;
                 }
@@ -464,7 +472,7 @@ function pingRootRouteTree(now, task, route) {
                 // behavior if PPR is disabled for a route (via the incremental opt-in).
                 //
                 // Those cases will be handled here.
-                spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(route, task.key));
+                spawnPrefetchSubtask((0, _cache.fetchRouteOnCacheMiss)(route, task.key, task.segmentCacheMap));
                 // If the request takes longer than a minute, a subsequent request should
                 // retry instead of waiting for this one. When the response is received,
                 // this value will be replaced by a new value based on the stale time sent
@@ -672,7 +680,7 @@ fetchStrategy) {
     }
     const segments = {
         tree: route.metadata,
-        entry: (0, _cache.readOrCreateSegmentCacheEntry)(now, fetchStrategy, route.metadata, task._navigationLockPrefetch ?? null),
+        entry: (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, route.metadata),
         parent: null
     };
     const needsRuntimeRequest = pingSegmentBundle(now, task, route, task.key, route.metadata, segments, fetchStrategy, true);
@@ -1035,7 +1043,7 @@ function pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, tree, ref
     // "inside-shared-layout" tells the server where to start looking for a
     // loading boundary.
     let refetchMarker = refetchMarkerContext === null ? 'inside-shared-layout' : null;
-    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.fetchStrategy, tree, task._navigationLockPrefetch ?? null);
+    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, task.fetchStrategy, tree);
     switch(segment.status){
         case _cache.EntryStatus.Empty:
             {
@@ -1050,7 +1058,7 @@ function pingPPRDisabledRouteTreeUpToLoadingBoundary(now, task, route, tree, ref
                 const pendingSegment = (0, _cache.upgradeToPendingSegment)(segment, // Set the fetch strategy to LoadingBoundary to indicate that the server
                 // might not include it in the pending response. If another route is able
                 // to issue a per-segment request, we'll do that in the background.
-                _types.FetchStrategy.LoadingBoundary, task._navigationLockPrefetch ?? null);
+                _types.FetchStrategy.LoadingBoundary);
                 spawnedEntries.set(tree.requestKey, pendingSegment);
                 // The pass blocks on every request it spawns, not just requests it
                 // finds already in flight.
@@ -1147,12 +1155,12 @@ function pingRouteTreeAndIncludeDynamicData(now, task, route, tree, isInsideRefe
     // explicit "refetch" marker so the server knows where to start rendering.
     // Once the server starts rendering along a path, it keeps rendering the
     // entire subtree.
-    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, // Note that `fetchStrategy` might be different from `task.fetchStrategy`,
+    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, // Note that `fetchStrategy` might be different from `task.fetchStrategy`,
     // and we have to use the former here.
     // We can have a task with `FetchStrategy.PPR` where some of its segments are configured to
     // always use runtime prefetching (via `export const prefetch`), and those should check for
     // entries that include search params.
-    fetchStrategy, tree, task._navigationLockPrefetch ?? null);
+    fetchStrategy, tree);
     let spawnedSegment = null;
     switch(segment.status){
         case _cache.EntryStatus.Empty:
@@ -1167,7 +1175,7 @@ function pingRouteTreeAndIncludeDynamicData(now, task, route, tree, isInsideRefe
                     }
                 }
                 // Include it in the request.
-                spawnedSegment = (0, _cache.upgradeToPendingSegment)(segment, fetchStrategy, task._navigationLockPrefetch ?? null);
+                spawnedSegment = (0, _cache.upgradeToPendingSegment)(segment, fetchStrategy);
                 break;
             }
         case _cache.EntryStatus.Fulfilled:
@@ -1185,7 +1193,7 @@ function pingRouteTreeAndIncludeDynamicData(now, task, route, tree, isInsideRefe
                     // entry from a previous navigation, prefer that over making a new
                     // request.
                     if (fetchStrategy === _types.FetchStrategy.Full) {
-                        const fulfilled = (0, _cache.attemptToUpgradeSegmentFromBFCache)(now, tree);
+                        const fulfilled = (0, _cache.attemptToUpgradeSegmentFromBFCache)(now, task.segmentCacheMap, tree);
                         if (fulfilled !== null) {
                             break;
                         }
@@ -1319,7 +1327,7 @@ spawnRevalidations) {
         }
         switch(nodeEntry.status){
             case _cache.EntryStatus.Empty:
-                (0, _cache.upgradeToPendingSegment)(nodeEntry, fetchStrategy, task._navigationLockPrefetch ?? null);
+                (0, _cache.upgradeToPendingSegment)(nodeEntry, fetchStrategy);
                 needsFetch = true;
                 // The pass blocks on every request it spawns, not just requests it
                 // finds already in flight.
@@ -1330,9 +1338,9 @@ spawnRevalidations) {
                 // wait for the in-flight response (blocked below); its sufficiency
                 // is checked on the re-run pass.
                 fetchStrategy === _types.FetchStrategy.PPR && (0, _cache.canNewFetchStrategyProvideMoreContent)(nodeEntry.fetchStrategy, fetchStrategy)) {
-                    const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, fetchStrategy, nodeTree);
+                    const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, fetchStrategy, nodeTree);
                     if (revalidatingEntry.status === _cache.EntryStatus.Empty) {
-                        (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy, task._navigationLockPrefetch ?? null);
+                        (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
                         node.entry = revalidatingEntry;
                         needsFetch = true;
                         // Block on the revalidation request we just spawned, in
@@ -1357,9 +1365,9 @@ spawnRevalidations) {
                 // prefetch at all — an edge that shouldn't occur for hint-set
                 // Cache Components routes.
                 fetchStrategy === _types.FetchStrategy.PPR && (0, _cache.canNewFetchStrategyProvideMoreContent)(nodeEntry.fetchStrategy, fetchStrategy)) {
-                    const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, fetchStrategy, nodeTree);
+                    const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, fetchStrategy, nodeTree);
                     if (revalidatingEntry.status === _cache.EntryStatus.Empty) {
-                        (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy, task._navigationLockPrefetch ?? null);
+                        (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
                         node.entry = revalidatingEntry;
                         needsFetch = true;
                         // Block on the retry revalidation we just spawned, like any
@@ -1414,9 +1422,9 @@ spawnRevalidations) {
                     // Do not attempt to upgrade if the status is Pending or Rejected.
                     (task.fallbackRetryStatus === _cache.EntryStatus.Empty || task.fallbackRetryStatus === _cache.EntryStatus.Fulfilled);
                     if (spawnRevalidations && !willBeSupersededByRuntimeRequest && (nodeEntry.isPartial && (0, _cache.canNewFetchStrategyProvideMoreContent)(nodeEntry.fetchStrategy, fetchStrategy) || isUpgradeableISRFallbackRetry)) {
-                        const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, fetchStrategy, nodeTree);
+                        const revalidatingEntry = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, fetchStrategy, nodeTree);
                         if (revalidatingEntry.status === _cache.EntryStatus.Empty) {
-                            (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy, task._navigationLockPrefetch ?? null);
+                            (0, _cache.upgradeToPendingSegment)(revalidatingEntry, fetchStrategy);
                             node.entry = revalidatingEntry;
                             needsFetch = true;
                             // The pass blocks on every request it spawns, including
@@ -1483,8 +1491,17 @@ spawnRevalidations) {
             needsRuntimeRequest: false
         };
     }
-    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, fetchStrategy, tree, task._navigationLockPrefetch ?? null);
+    const segment = (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, tree);
     if (process.env.__NEXT_PREFETCH_INLINING && tree.prefetchHints & _approutertypes.PrefetchHint.InlinedIntoChild) {
+        if (segment.status === _cache.EntryStatus.Pending) {
+            // The chain this entry joins may be dropped before it's ever pinged
+            // (see the drop sites in pingNewPartOfCacheComponentsTree), and only
+            // the ping blocks on Pending entries. Register on the in-flight
+            // response at read time instead, so the pass observes it before the
+            // phase can complete even if the chain is dropped. When the chain does
+            // get pinged, the ping's own registration dedupes against this one.
+            blockTaskOnPendingResponse(task, segment);
+        }
         return {
             bundle: {
                 tree,
@@ -1507,7 +1524,7 @@ spawnRevalidations) {
     if (process.env.__NEXT_PREFETCH_INLINING && tree.prefetchHints & _approutertypes.PrefetchHint.HeadInlinedIntoSelf) {
         effectiveParent = {
             tree: route.metadata,
-            entry: (0, _cache.readOrCreateSegmentCacheEntry)(now, fetchStrategy, route.metadata, task._navigationLockPrefetch ?? null),
+            entry: (0, _cache.readOrCreateSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, route.metadata),
             parent: parentBundle
         };
     }
@@ -1543,14 +1560,14 @@ fetchStrategy) {
     }
 }
 function pingFullSegmentRevalidation(now, task, tree, fetchStrategy) {
-    const revalidatingSegment = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, fetchStrategy, tree);
+    const revalidatingSegment = (0, _cache.readOrCreateRevalidatingSegmentEntry)(now, task.segmentCacheMap, fetchStrategy, tree);
     if (revalidatingSegment.status === _cache.EntryStatus.Empty) {
         // During a Full/PPRRuntime prefetch, a single dynamic request is made for all the
         // segments that we need. So we don't initiate a request here directly. By
         // returning a pending entry from this function, it signals to the caller
         // that this segment should be included in the request that's sent to
         // the server.
-        const pendingSegment = (0, _cache.upgradeToPendingSegment)(revalidatingSegment, fetchStrategy, task._navigationLockPrefetch ?? null);
+        const pendingSegment = (0, _cache.upgradeToPendingSegment)(revalidatingSegment, fetchStrategy);
         // The upsert is handled by fulfillEntrySpawnedByRuntimePrefetch
         // when the dynamic prefetch response is written into the cache.
         return pendingSegment;
@@ -1560,8 +1577,8 @@ function pingFullSegmentRevalidation(now, task, tree, fetchStrategy) {
         if ((0, _cache.canNewFetchStrategyProvideMoreContent)(nonEmptyRevalidatingSegment.fetchStrategy, fetchStrategy)) {
             // The existing revalidation was fetched using a less specific strategy.
             // Reset it and start a new revalidation.
-            const emptySegment = (0, _cache.overwriteRevalidatingSegmentCacheEntry)(now, fetchStrategy, tree);
-            const pendingSegment = (0, _cache.upgradeToPendingSegment)(emptySegment, fetchStrategy, task._navigationLockPrefetch ?? null);
+            const emptySegment = (0, _cache.overwriteRevalidatingSegmentCacheEntry)(now, task.segmentCacheMap, fetchStrategy, tree);
+            const pendingSegment = (0, _cache.upgradeToPendingSegment)(emptySegment, fetchStrategy);
             // The upsert is handled by fulfillEntrySpawnedByRuntimePrefetch
             // when the dynamic prefetch response is written into the cache.
             return pendingSegment;

package/.next/standalone/node_modules/next/dist/client/route-params.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    canonicalizeURLPart: null,
     doesStaticSegmentAppearInURL: null,
     getCacheKeyForDynamicParam: null,
     getParamValueFromCacheKey: null,
@@ -19,6 +20,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    canonicalizeURLPart: function() {
+        return canonicalizeURLPart;
+    },
     doesStaticSegmentAppearInURL: function() {
         return doesStaticSegmentAppearInURL;
     },
@@ -72,14 +76,6 @@ function getRenderedPathname(response) {
     const pathname = urlToUrlWithoutFlightMarker(new URL(response.url)).pathname;
     return (0, _hasbasepath.hasBasePath)(pathname) ? (0, _removebasepath.removeBasePath)(pathname) : pathname;
 }
-// Pathname parts come from `URL.pathname.split('/')`, so they are already
-// in the encoded form the URL parser produces. The server-side equivalent
-// (`get-dynamic-param.ts`) starts from a decoded param value and applies
-// `encodeURIComponent` once. The two encodings are not the same — for
-// example, the URL parser leaves `,` and `:` untouched while
-// `encodeURIComponent` percent-encodes them. To produce the same canonical
-// form on the client (and avoid double-encoding `%xx` sequences such as
-// `%2F` → `%252F`), we decode the URL part first and re-encode it.
 function canonicalizeURLPart(part) {
     try {
         return encodeURIComponent(decodeURIComponent(part));