1. 29 Sep, 2026 1 commit
  2. 22 Sep, 2026 3 commits
    • Luke Sandberg's avatar
      [backport] turbo-tasks-backend: fix strongly consistent read hanging on a canceled task (#98931) · 2521aec5
      Luke Sandberg authored
      Backports #98312 ("turbo-tasks-backend: fix strongly consistent read
      hanging on a canceled task") to `next-16-3`.
      
      ### What?
      
      `next build` could hang at shutdown on the 16.3 line: a strongly
      consistent read would wait forever on a task that shutdown had already
      canceled, which in turn blocked `stop_and_wait`. This brings the
      upstream fix, and its regression test, to the release branch.
      
      ### Why?
      
      A canceled task has no output, and `has_output()` is used as the proxy
      for "not computed yet". Shutdown therefore made the canceled child look
      like work still to be scheduled: it was marked dirty and contributed a
      dirty container that could never drain, because the (clean) parent never
      re-evaluates `all_clean_event`. The strongly consistent reader waited on
      that event indefinitely while holding a foreground job that shutdown
      blocks on.
      
      ### How?
      
      The fix records a terminal error output when a task execution is
      canceled, so a canceled task is no longer indistinguishable from an
      uncomputed one and the dirty-container accounting drains as it should.
      It also makes the `hanging_detection` feature usable again, which
      previously panicked on a `data` access check.
      
      The source change is the upstream one, unmodified. One release-branch
      adaptation was required: the backported regression test pulls in a
      shared `tests/util.rs` helper that does not exist on `next-16-3` — it
      was extracted on `canary` by unrelated later commits. A minimal version
      is added here, providing only the persistent-backend setup the test
      needs and written against this branch's APIs (`BackendOptions` has no
      `gc` field here, and `turbo_backing_storage` still takes positional
      `is_ci` / `is_short_session` / `skip_compaction` arguments). It follows
      the same shape as the existing inline helper in `tests/eviction.rs`.
      
      ### Verification
      
      - The regression test was run against an unmodified `next-16-3`
      checkout, where it reproduces the bug: it hangs and fails after 30s with
      "stop_and_wait hung: a cancelled task stranded a strongly consistent
      reader". With this change it passes.
      - `cargo fmt --check`, `cargo clippy -p turbo-tasks-backend
      --all-targets` and the full `cargo test -p turbo-tasks-backend` suite
      are clean.
      - `pnpm build-all` succeeds.
      
      <!-- NEXT_JS_LLM -->
      
      
      <!-- fleet 33c5c205-5580-40f2-bcf8-5f91a945ef4b -->
      Co-authored-by: 's avatarvercel-fleet-prod[bot] <318278635+vercel-fleet-prod[bot]@users.noreply.github.com>
      Co-authored-by: 's avatarLuke Sandberg <210140+lukesandberg@users.noreply.github.com>
      2521aec5
    • next-js-bot[bot]'s avatar
      v16.3.6 · a758ffcf
      next-js-bot[bot] authored
      a758ffcf
    • Josh Story's avatar
  3. 17 Sep, 2026 1 commit
  4. 11 Sep, 2026 1 commit
  5. 10 Sep, 2026 2 commits
  6. 07 Sep, 2026 1 commit
    • Joseph's avatar
      [16.3.x] Backport docs fixes (#98317) · 4b56cee3
      Joseph authored
      - docs: explain origin matching for allowedOrigins and allowedDevOrigins
      (#97805)
      - docs: improve discovery summaries (#97982)
      - docs(skills): preserve prefetched UI during Partial Prefetching
      adoption (#97712)
      - docs: add layout stability guidance for videos and iframes (#98070)
      - docs: document preloading with Cache Components (#97864)
      - docs: note that experimental.taint taints process.env (#98145)
      - docs: add API reference pages for skipProxyUrlNormalize and
      skipTrailingSlashRedirect (#97967)
      - docs: keep generateStaticParams during Cache Components migration
      (docs part of #98209)
      - docs: Remove version label from Turbopack in Pages Router (#98316)
      
      ---------
      Co-authored-by: 's avatarRich Haines <hello@richardhaines.dev>
      Co-authored-by: 's avatarAurora Scharff <66901228+aurorascharff@users.noreply.github.com>
      4b56cee3
  7. 04 Sep, 2026 2 commits
  8. 03 Sep, 2026 2 commits
  9. 02 Sep, 2026 1 commit
  10. 01 Sep, 2026 1 commit
  11. 31 Aug, 2026 3 commits
  12. 28 Aug, 2026 2 commits
  13. 27 Aug, 2026 1 commit
  14. 25 Aug, 2026 4 commits
  15. 24 Aug, 2026 1 commit
  16. 21 Aug, 2026 1 commit
  17. 20 Aug, 2026 2 commits
  18. 19 Aug, 2026 1 commit
  19. 18 Aug, 2026 1 commit
  20. 15 Aug, 2026 1 commit
  21. 14 Aug, 2026 1 commit
  22. 13 Aug, 2026 7 commits
    • next-js-bot[bot]'s avatar
      v16.3.1 · 3d32eb87
      next-js-bot[bot] authored
      3d32eb87
    • Jude Gao's avatar
      [backport] Revert i18n localization change for dynamic Pages API routes (#94905) (#97330) · 2b4b1ec1
      Jude Gao authored
      Backports #97327 ("Revert i18n localization change for dynamic Pages API
      routes (#94905)") to `next-16-3`.
      
      Clean cherry-pick of `2f84a1f2` — `next-16-3` carries the exact code
      being reverted, so it applies as-is.
      
      Restores i18n locale prefixing for dynamic Pages API routes, so the
      emitted matcher and the adapter's i18n rules agree again on whether
      `/api/...` carries a locale prefix. When they disagree the matcher is
      unreachable and requests fall through to `/{locale}/404`.
      
      Pairs with the adapter revert (nextjs/adapter-vercel#101, published as
      `adapter-vercel@0.0.1-beta.26`). Full rationale and reproduction in
      #97327.
      2b4b1ec1
    • Luke Sandberg's avatar
      [backport] Retain fewer stale cache versions and use a TTL, plus the mtime fallback (#97304) · 228df5fd
      Luke Sandberg authored
      Backports the following to `next-16-3`, as a pair:
      
      - #96941 — "[turbopack] Retain fewer stale cache versions and use a TTL"
      (`ae1e53a1`)
      - #97268 — "Add the mtime fallback back" (`52a3410d`)
      
      The second fixes a bug in the first: #96941 changes the `CURRENT` file
      format from a bare
      big-endian `u32` to a JSON object, and an existing cache directory in
      the old format could no
      longer be aged. #97268 adds the mtime fallback so an unparsable
      `CURRENT` is aged by its mtime
      instead of failing. They only make sense together, hence one branch.
      
      Both cherry-picked with `-x`, no conflicts. Every touched source file is
      byte-identical to canary.
      
      ### Verification on this branch
      
      - `cargo check`, `cargo clippy --all-targets`, `cargo fmt --check` on
      `turbo-persistence` and `turbo-tasks-backend` — clean
      - `cargo test -p turbo-persistence -p turbo-tasks-backend` — all pass, 0
      failures
      - includes the `db_versioning` tests, notably
      `test_unparsable_current_falls_back_to_mtime::case_1_old_u32_format`
      (the old-format compatibility case #97268 restores)
      - `cargo metadata --locked` — `Cargo.lock` consistent with the
      manifests, no lockfile update needed
      - `pnpm --filter=next types`, prettier, eslint — clean
      - `pnpm build-all` — 18/18 tasks
      - `test/production/next-server-nft` — 5/5 tests, 5/5 snapshots pass
      (covers the traced `turbopack-cache-seed.js`)
      
      ### End-to-end verification against a real old-format cache
      
      `create-next-app@16.3.0` + `next build` (with
      `turbopackFileSystemCacheForBuild`) on released
      `next@16.3.0` writes a `CURRENT` in the old pre-JSON format — a bare
      big-endian `u32`
      (`0000 0008`), 30M cache. This branch was then applied with
      `pnpm pack-next -p <app> -- --release` (release binary confirmed to
      contain
      `TURBO_ENGINE_VERSION_TTL_DAYS` and the new `CURRENT` field names), and
      two arms were run from
      an identical starting state — same cache, same code, only the env var
      differing:
      
      | Arm | Build | Cache dirs after |
      | --- | --- | --- |
      | `TURBO_ENGINE_VERSION_TTL_DAYS=0` | exit 0 | old dir **deleted**, 1
      remains |
      | default TTL (3 days) | exit 0 | old dir **retained**, intact at 30M, 2
      remain |
      
      The retention arm is the meaningful control: without #97268's fallback,
      `read_current_version`
      would error on the bare-`u32` file, the age would become
      `Duration::MAX`, and the directory would
      be evicted in *both* arms. Retention under the default TTL is direct
      evidence the mtime fallback
      works.
      
      Also confirmed:
      
      - new `CURRENT` is written as JSON:
      `{"max_sequence_number":8,"commit_time":"..."}`
      - retention cap holds: seeded 4 version dirs → build left exactly 2
      (current + one most-recently-used other)
      - clean deletion, no `DELETION_PREFIX` leftovers in any run
      - `TURBO_ENGINE_VERSION_TTL_DAYS=notanumber` warns (`expected a whole
      number of days`) and falls back to the 3-day default rather than failing
      
      <!-- NEXT_JS_LLM -->
      228df5fd
    • Andrew Clark's avatar
      [backport] Fix: Optimistic routing bugs leading to repeated prefetch loops (#97325) · 16eab3ac
      Andrew Clark authored
      Backports #97128 ("Fix: Optimistic routing bugs leading to repeated
      prefetch loops") to `next-16-3`.
      
      Fixes an infinite prefetch loop in optimistic routing. A proxy that
      rewrites every URL to inject a leading path segment — i18n with the
      default locale hidden from the URL, so `/one/two` is served as
      `/en/one/two` — combined with a fully dynamic target route like
      `/[locale]/[...pages]`, produces a prefetch that never settles. When a
      prefetch response came back, the client never checked whether the
      rendered tree matched the one it had requested. When the params baked
      into the request were wrong because of the rewrite, the task kept
      re-attempting to fulfill the missing data and looped forever.
      
      The prefetch path now records a dynamic-rewrite marker on the local
      route definition when the response's tree diverges from the requested
      one, which disables further optimistic resolution of that route and
      invalidates the entries derived from it. This is the same strategy
      normal navigation responses already used, now applied to the prefetch
      path.
      
      A second, related bug is also fixed: parallel routes with conflicting
      dynamic params at the same level (`@modal/[...catchAll]` next to
      `[username]`) can't be distinguished by the traversal algorithm, which
      assumes each segment resolves independently without inspecting sibling
      branches. When that scenario is detected, optimistic routing is now
      disabled for the conflicting route rather than binding one branch's URL
      parts to another branch's params.
      
      ### Verification on this branch
      
      Cherry-picked from `5942b37a`. Three source files conflicted, all
      because `next-16-3` predates the post-16.3.0 refactor that split the
      client's response decoder into its own module:
      
      - `segment-cache/decode-server-response.ts` — this file does not exist
      on this branch; it was extracted out of `navigation.ts` after 16.3.0.
      Its change (tracking whether the decoded tree's segment identities
      diverge from the base request tree) was ported into `navigation.ts`,
      where the equivalent logic still lives. Canary decodes a compact
      transport tree and compares segment identities inline during the walk;
      this branch instead merges the response patch onto the base
      `FlightRouterState` before converting it to a `RouteTree`. The check is
      therefore re-expressed as a read-only walk in
      `convertServerPatchToFullTree` that compares each server patch against
      the base tree it is applied to, following canary's descent
      (`convertServerPatchToFullTreeImpl`) exactly and using the same
      comparison rules: segment identity via `matchSegment`, page segments
      matched modulo embedded search params, server-filled `__DEFAULT__`
      segments ignored, and inactive parallel-route branches (those carrying a
      refresh state in the base) skipped. The result is threaded out through
      `NavigationSeed.treeDivergedFromBase`.
      - `segment-cache/cache.ts` — the consuming block in
      `fetchSegmentPrefetchesUsingDynamicRequest` (mark-as-dynamic-rewrite,
      invalidate derived entries, reject with immediate expiry) is
      byte-identical to canary. The surrounding conflicts were only
      incidental: the `RouteTreeAccumulator` type gaining
      `treeDivergedFromBase`, and canary's transport-decoder call vs. this
      branch's `convertRootFlightRouterStateToRouteTree`. Resolved by keeping
      this branch's calls and adding the new field to the accumulators.
      Canary's inline `NavigationSeed` construction in
      `writeDynamicTreeResponseIntoCache` does not apply here because that
      function delegates to `convertServerPatchToFullTree`, which now carries
      the field.
      - `router-reducer/create-initial-router-state.ts` — a one-line
      accumulator initializer; kept this branch's
      `convertRootFlightRouterStateToRouteTree` call and added
      `treeDivergedFromBase: false`.
      
      The other touched source files applied cleanly and are byte-identical to
      canary: `segment-cache/optimistic-routes.ts` (the parallel-route
      conflict detection) and `route-params.ts` (exporting
      `canonicalizeURLPart`), along with `ppr-navigations.ts`, the small
      cleanly-applied hunk in `navigation.ts`, and every test fixture.
      
      `tsc` passes on the `next` package for all files touched here.
      Behavioral verification is left to CI on this branch; the change carries
      the `proxy-prefix-rewrite-prefetch-loop` and
      `modal-catchall-sibling-dynamic-prefetch-loop` end-to-end suites plus
      additions to the `optimistic-routing` suite.
      
      Opened as a draft because the `decode-server-response.ts` →
      `navigation.ts` port is a manual re-implementation across the refactor
      boundary rather than a mechanical cherry-pick. The divergence walk in
      `convertServerPatchToFullTree` is the part most worth a close review.
      
      <!-- NEXT_JS_LLM -->
      16eab3ac
    • Andrew Clark's avatar
      [backport] Fix Nav Inspector request loop on repeat captures (#97326) · 75548c9a
      Andrew Clark authored
      Backports #97050 ("Fix Nav Inspector request loop on repeat captures")
      to `next-16-3`.
      
      With the Nav Inspector enabled, clicking a `<Link prefetch={true}>`,
      closing the inspector, navigating home, re-enabling it, and clicking the
      same link left the app hung in a pending "Compiling…" state while it
      fired prefetch requests in an infinite loop (~30/sec). The Instant
      Navigation Testing lock restricted navigation reads to entries created
      within the current lock scope (`ownedEntries`), enforced as a post-hoc
      filter after the cache lookup. Because the segment cache resolves
      lookups by most-specific-match, a previous scope's runtime-prefetch
      entries at concrete param keypaths kept winning the lookup, the filter
      kept rejecting them, and the locked prefetch created its replacement at
      a more generic keypath that could never win — so every scheduler pass
      discarded and refetched forever.
      
      Rather than patch the filter, the fix replaces the `ownedEntries`
      mechanism with a per-scope segment `CacheMap`. Each lock scope owns a
      private map that starts empty and is discarded at release, so a captured
      navigation structurally observes only data fetched under the lock. The
      map is bound to a unit of work when it is created: a prefetch task
      captures its map when scheduled (`PrefetchTask.segmentCacheMap`, the
      single place that consults lock state), a locked navigation inherits its
      driving task's map, and everything else — unlocked navigations,
      hydration, refreshes, history-traversal restores, server actions and
      patches — binds to the shared map. Reads and response writes receive the
      map explicitly, so a request that straddles a scope boundary still
      writes into the map its entries live in.
      
      In production builds without the testing API this compiles down to the
      previous single-map behavior, so the non-testing paths are unchanged.
      
      ### Verification on this branch
      
      Cherry-picked from `5dc3ae1f`. Three files conflicted; each was
      resolved by keeping the release branch's existing code shape and
      applying only the fix's actual change — threading the segment `CacheMap`
      through as an explicit parameter.
      
      - **`refresh-reducer.ts`** and **`restore-reducer.ts`** — the conflicts
      were confined to the import block. Canary imports
      `convertServerPatchToFullTree` from
      `./segment-cache/decode-server-response`, a module that doesn't exist on
      this branch; `next-16-3` still imports it from
      `./segment-cache/navigation`. I kept the release branch's import source
      and added the new `segmentCacheMap` import alongside it. The
      function-body changes (passing `segmentCacheMap` as the shared map)
      applied cleanly, and the `startPPRNavigation`/`spawnDynamicRequests`
      argument order lines up with this branch's signatures.
      
      - **`cache.ts`** — the substantive one. `next-16-3` predates the
      post-16.3.0 segment-cache refactors, so three areas differ from canary
      and had to be adapted rather than taken verbatim from the patch: (1)
      `RouteTree` is still non-generic here (`RouteTree`, not
      `RouteTree<RSCSegmentData | null>` — this branch has no `RSCSegmentData`
      and the tree doesn't carry render data), so the three signatures the
      patch retyped were kept as plain `RouteTree`; (2)
      `writeSegmentBundleResponse` still has the older `StaticShell`/`else`
      re-key split guarded by `__NEXT_VARY_PARAMS`, versus canary's single
      `upsertSegmentEntry` — I kept the release-branch logic and threaded
      `map` into both of its `upsertSegmentEntry` calls; (3)
      `writeDynamicRenderResponseIntoCache` and `writeSeedDataIntoCache` still
      use the `flightDatas` + `CacheNodeSeedData` write model rather than
      canary's route-tree-carries-data model — I kept the release-branch
      traversal and threaded `map` into each `writeSeedDataIntoCache` /
      `fulfillEntrySpawnedByRuntimePrefetch` call. Everything else in
      `cache.ts` — the `ownedEntries` removal, the `segmentCacheMap` export,
      `insertEmptySegmentCacheEntry`, and the `map` parameter added to every
      read/write helper — applied cleanly and is identical to canary. I
      confirmed no stale references to the removed `ownedEntries` /
      `readSegmentCacheEntry` / `navigationLockPrefetch`-param APIs remain,
      and that every call site of the retyped helpers passes a map.
      
      The remaining files applied without conflict. `server-patch-reducer.ts`,
      `navigation-testing-lock.ts`, `navigation-testing-lock.disabled.ts`, and
      the `instant-navs-devtools` test are byte-identical to canary.
      `create-initial-router-state.ts`, `ppr-navigations.ts`,
      `server-action-reducer.ts`, `navigation.ts`, and `scheduler.ts` differ
      from canary only in pre-existing `next-16-3` divergence (the older
      transport-data / route-tree models); the fix's own hunks (the
      `segmentCacheMap` threading) applied to them cleanly. No local typecheck
      was run — this fresh worktree has no `node_modules` and installing it
      carries the known corepack/SWC-binary gotchas — so behavioral and type
      verification is left to CI on this branch, which carries the
      `instant-navs-devtools` regression test from #96692.
      
      **Reviewer, focus here:** the `writeSegmentBundleResponse` resolution in
      `cache.ts` (area 2 above) is the hunk I'd most like a second pair of
      eyes on. I preserved this branch's `StaticShell`/`else` re-key branch
      structure and only inserted the `map` argument into its two
      `upsertSegmentEntry` calls; please confirm that routing both branches'
      writes through the task's bound map (rather than the module-level
      `segmentCacheMap`) is the correct behavior for the older re-key logic.
      
      <!-- NEXT_JS_LLM -->
      Co-authored-by: 's avatarSam Selikoff <sam.selikoff@gmail.com>
      75548c9a
    • Luke Sandberg's avatar
      [backport] [test] Compile the middleware redirect routes up front in dev (#97328) · f6bd714a
      Luke Sandberg authored
      Backports #97190 ("[test] Compile the middleware redirect routes up
      front in dev") to `next-16-3`.
      
      <!-- NEXT_JS_LLM -->
      Co-authored-by: 's avatarHendrik Liebau <mail@hendrik-liebau.de>
      f6bd714a
    • Sebastian "Sebbie" Silbermann's avatar