1. 31 Aug, 2026 16 commits
    • next-js-bot[bot]'s avatar
      v16.4.0-canary.13 · 258b1c1b
      next-js-bot[bot] authored
      258b1c1b
    • Jude Gao's avatar
      evals: stop requiring the removed viewTransition flag in agent-043 (#98116) · fb49d8b7
      Jude Gao authored
      The view-transitions eval kept requiring a config option that #96098
      removed, so models following the current docs were failed for correct
      solutions. Evals only, no runtime change.
      Co-authored-by: 's avatarClaude Fable 5 <noreply@anthropic.com>
      fb49d8b7
    • Aurora Scharff's avatar
      errors: shorten "use cache" messages and unify them into one factory (#94300) · e9180eae
      Aurora Scharff authored
      ### What?
      
      Centralizes related <code>"use cache"</code> scope errors and rewrites
      them as shorter, actionable messages with consistent <code>Learn
      more:</code> links. It also updates the reachable revalidation errors
      for rendering and <code>generateStaticParams</code>.
      
      ### Why?
      
      The previous messages were long, inconsistent, and sometimes missing
      documentation links. Some new cache-specific revalidation messages were
      also hidden by an earlier render-phase error. The new messages name the
      constraint, give the immediate fix, and link to the relevant
      documentation.
      
      ### How?
      
      Adds centralized error factories and dedicated error pages for request
      data, cache configuration, private-cache composition, and revalidation.
      When an active App Router route is available, the messages include it.
      The error pages use consistent terminology and complete examples. The
      <code>unstable_cache()</code> reference now documents the
      request-dependent operations that these errors reject.
      
      ### Before and after
      
      Route-based examples use <code>/products</code>. Bracketed values are
      alternatives in matching order. For example, <code>[E1482, E1486,
      E1489]</code> maps to <code>[headers(), cookies(), request.url]</code>.
      Each runtime error contains one alternative, but the table groups
      messages with the same template.
      
      #### Messages that include the route
      
      | Cases | Before | After |
      | --- | --- | --- |
      | E1480 · <code>searchParams</code> in <code>"use cache"</code> | Route
      /products used <code>searchParams</code> inside "use cache". Accessing
      dynamic request data inside a cache scope is not supported. If you need
      some search params inside a cached function await
      <code>searchParams</code> outside of the cached function and pass only
      the required search params as arguments to the cached function. See more
      info here: https://nextjs.org/docs/messages/next-request-in-use-cache |
      Route "/products": <code>searchParams</code> can't be read inside
      <code>"use cache"</code>. Await it outside the cached function and pass
      what you need as an argument.<br><br>Learn more:
      https://nextjs.org/docs/messages/next-request-in-use-cache |
      | [E1482, E1486, E1489] · [<code>headers()</code>,
      <code>cookies()</code>, <code>request.url</code>] in <code>"use
      cache"</code> | Route /products used [<code>headers()</code>,
      <code>cookies()</code>, <code>request.url</code>] inside "use cache".
      Accessing Dynamic data sources inside a cache scope is not supported. If
      you need this data inside a cached function use [<code>headers()</code>,
      <code>cookies()</code>, <code>request.url</code>] outside of the cached
      function and pass the required dynamic data in as an argument. See more
      info here: https://nextjs.org/docs/messages/next-request-in-use-cache |
      Route "/products": [<code>headers()</code>, <code>cookies()</code>,
      <code>request.url</code>] can't be read inside <code>"use cache"</code>.
      Read it outside the cached function and pass what you need as an
      argument.<br><br>Learn more:
      https://nextjs.org/docs/messages/next-request-in-use-cache |
      | [E1481, E1485, E1492] · [<code>cookies()</code>,
      <code>request.url</code>, <code>headers()</code>] in
      <code>unstable_cache()</code> | Route /products used
      [<code>cookies()</code>, <code>request.url</code>,
      <code>headers()</code>] inside a function cached with
      <code>unstable_cache()</code>. Accessing Dynamic data sources inside a
      cache scope is not supported. If you need this data inside a cached
      function use [<code>cookies()</code>, <code>request.url</code>,
      <code>headers()</code>] outside of the cached function and pass the
      required dynamic data in as an argument. See more info here:
      https://nextjs.org/docs/app/api-reference/functions/unstable_cache |
      Route "/products": [<code>cookies()</code>, <code>request.url</code>,
      <code>headers()</code>] can't be read inside
      <code>unstable_cache()</code>. Read it outside the cached function and
      pass what you need as an argument.<br><br>Learn more:
      https://nextjs.org/docs/app/api-reference/functions/unstable_cache |
      | [E1484, E1491] · <code>draftMode().enable()</code> in
      [<code>unstable_cache()</code>, <code>"use cache"</code>] | Route
      /products used "draftMode().enable()" inside [a function cached with
      <code>unstable_cache()</code>, "use cache"]. The enabled status of
      <code>draftMode()</code> can be read in caches but you must not enable
      or disable <code>draftMode()</code> inside a cache. See more info here:
      [https://nextjs.org/docs/app/api-reference/functions/unstable_cache,
      https://nextjs.org/docs/messages/next-request-in-use-cache] | Route
      "/products": <code>draftMode().enable()</code> can't be called inside
      [<code>unstable_cache()</code>, <code>"use cache"</code>]. Draft mode
      can be read inside a cached function, but enabling or disabling it must
      happen outside.<br><br>Learn more:
      [https://nextjs.org/docs/app/api-reference/functions/unstable_cache,
      https://nextjs.org/docs/messages/next-request-in-use-cache] |
      | [E1488, E1499] · <code>connection()</code> in
      [<code>unstable_cache()</code>, <code>"use cache"</code>] | Route
      /products used <code>connection()</code> inside [a function cached with
      <code>unstable_cache()</code>, "use cache"]. The
      <code>connection()</code> function is used to indicate the subsequent
      code must only run when there is an actual request, but caches must be
      able to be produced before a request, so this function is not allowed in
      this scope. See more info here:
      [https://nextjs.org/docs/app/api-reference/functions/unstable_cache,
      https://nextjs.org/docs/messages/next-request-in-use-cache] | Route
      "/products": <code>connection()</code> can't be called inside
      [<code>unstable_cache()</code>, <code>"use cache"</code>] because cached
      functions may run during prerendering, without an incoming request. Call
      it outside the cached function.<br><br>Learn more:
      [https://nextjs.org/docs/app/api-reference/functions/unstable_cache,
      https://nextjs.org/docs/messages/next-request-in-use-cache] |
      | E1494 · <code>connection()</code> in <code>"use cache: private"</code>
      | Route /products used <code>connection()</code> inside "use cache:
      private". The <code>connection()</code> function is used to indicate the
      subsequent code must only run when there is an actual navigation
      request, but caches must be able to be produced before a navigation
      request, so this function is not allowed in this scope. See more info
      here: https://nextjs.org/docs/messages/next-request-in-use-cache | Route
      "/products": <code>connection()</code> can't be called inside <code>"use
      cache: private"</code> because private cached functions may run during
      prefetching, without a navigation request. Call it outside the cached
      function.<br><br>Learn more:
      https://nextjs.org/docs/app/api-reference/directives/use-cache-private |
      | [E1483, E1495] · <code>revalidateTag("products")</code> in [<code>"use
      cache"</code>, <code>unstable_cache()</code>] | Route /products used
      "revalidateTag products" inside [a "use cache", a function cached with
      "unstable_cache(...)"] which is unsupported. To ensure revalidation is
      performed consistently it must always happen outside of renders and
      cached functions. See more info here:
      https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering
      | Route "/products": <code>revalidateTag("products")</code> can't be
      called during render, inside a cached function, or inside
      <code>generateStaticParams</code>. Call it from a Server Action or Route
      Handler instead.<br><br>Learn more:
      https://nextjs.org/docs/messages/revalidate-in-use-cache |
      | During render | Route /products used "revalidateTag products" during
      render which is unsupported. To ensure revalidation is performed
      consistently it must always happen outside of renders and cached
      functions. See more info here:
      https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering
      | Route "/products": <code>revalidateTag("products")</code> can't be
      called during render, inside a cached function, or inside
      <code>generateStaticParams</code>. Call it from a Server Action or Route
      Handler instead.<br><br>Learn more:
      https://nextjs.org/docs/messages/revalidate-in-use-cache |
      | Inside <code>generateStaticParams</code> | Route /products used
      "revalidateTag products" inside <code>generateStaticParams</code> which
      is unsupported. To ensure revalidation is performed consistently it must
      always happen outside of renders and cached functions. See more info
      here:
      https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering
      | Route "/products": <code>revalidateTag("products")</code> can't be
      called inside <code>generateStaticParams</code>. Call it from a Server
      Action or Route Handler instead.<br><br>Learn more:
      https://nextjs.org/docs/messages/revalidate-in-use-cache |
      
      #### Other messages
      
      | Cases | Before | After |
      | --- | --- | --- |
      | [E1477, E1490] · Nested cache with [short <code>expire</code>,
      <code>revalidate: 0</code>] | A "use cache" with [short
      <code>expire</code> (under 5 minutes), zero <code>revalidate</code>] is
      nested inside another "use cache" that has no explicit
      <code>cacheLife</code>, which is not allowed during prerendering. Add
      <code>cacheLife()</code> to the outer "use cache" to choose whether it
      should be prerendered [with longer <code>expire</code>, with non-zero
      <code>revalidate</code>] or remain dynamic [with short
      <code>expire</code>, with zero <code>revalidate</code>]. Read more:
      https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife
      | Route <code>"/products"</code>: A nested <code>"use cache"</code> with
      [a short <code>expire</code> (under 5 minutes), <code>revalidate:
      0</code>] is inside an outer <code>"use cache"</code> that has no
      <code>cacheLife()</code>. Add <code>cacheLife()</code> to the outer one
      to choose whether to prerender it [with a longer <code>expire</code>,
      with a non-zero <code>revalidate</code>] or keep it dynamic [with a
      short <code>expire</code>, with <code>revalidate:
      0</code>].<br><br>Learn more:
      https://nextjs.org/docs/messages/nested-use-cache-no-explicit-cachelife
      |
      | E1478 · External promise | Filling a "use cache" entry appears to be
      stuck on shared state from the outer render scope. The same function
      completed when run in isolation, which usually means a module-scoped
      value (for example a top-level Map used to dedupe fetches) is joining a
      promise created outside the cache. "use cache" already dedupes calls
      with the same arguments within a request and across requests on the same
      server instance, so the surrounding dedupe layer is both unnecessary and
      the likely cause. Remove it and rely on "use cache" alone for
      deduping.<br><br><em>No documentation link.</em> | Route
      <code>"/products"</code>: A <code>"use cache"</code> function is
      awaiting a promise created outside it. The same call completed when run
      in isolation, so a module-scoped value (often a top-level
      <code>Map</code> used to dedupe fetches) is most likely blocking it.
      <code>"use cache"</code> already dedupes calls with the same arguments.
      Remove the surrounding dedupe layer.<br><br>Learn more:
      https://nextjs.org/docs/messages/next-request-in-use-cache |
      | [E1479, E1498] · [<code>cacheTag()</code>, <code>cacheLife()</code>]
      outside a cached function | [<code>cacheTag()</code>,
      <code>cacheLife()</code>] can only be called inside a "use cache"
      function.<br><br><em>No documentation link.</em> | Route
      <code>"/products"</code>: [<code>cacheTag()</code>,
      <code>cacheLife()</code>] can only be called inside a <code>"use
      cache"</code> or <code>"use cache: private"</code>
      function.<br><br>Learn more:
      [https://nextjs.org/docs/messages/cache-tag-outside-use-cache,
      https://nextjs.org/docs/messages/cache-life-outside-use-cache]<br><br>Outside
      an App Router route, the same message is shown without the route prefix.
      |
      | E1487 · Prerender timeout | Filling a cache during prerender timed
      out, likely because request-specific arguments such as params,
      searchParams, cookies() or dynamic data were used inside "use
      cache".<br><br><em>No documentation link.</em> | Route
      <code>"/products"</code>: A <code>"use cache"</code> function took too
      long during prerendering. The most common cause is passing unresolved
      request-specific arguments, such as <code>params</code> or
      <code>searchParams</code>, into the cached function. Resolve the data
      before calling the function and pass only the values you
      need.<br><br>Learn more:
      https://nextjs.org/docs/messages/next-request-in-use-cache |
      | E1493 · Private cache inside a public cache | "use cache: private"
      must not be used within "use cache". It can only be nested inside of
      another "use cache: private".<br><br><em>No documentation link.</em> |
      Route <code>"/products"</code>: <code>"use cache: private"</code> can't
      be nested inside <code>"use cache"</code> because a shared cached
      function can't depend on private request data. Nest it only inside
      another <code>"use cache: private"</code>.<br><br>Learn more:
      https://nextjs.org/docs/messages/use-cache-private-composition |
      | E1496 · Private cache without a request | "use cache: private" cannot
      be used outside of a request context.<br><br><em>No documentation
      link.</em> | Route <code>"/products"</code>: <code>"use cache:
      private"</code> needs an active request, so it can't be used during
      <code>generateStaticParams</code> or other build-time contexts. Move it
      to a request-time component or function.<br><br>Learn more:
      https://nextjs.org/docs/messages/use-cache-private-composition |
      | E1497 · Private cache inside <code>unstable_cache()</code> | "use
      cache: private" must not be used within
      <code>unstable_cache()</code>.<br><br><em>No documentation link.</em> |
      Route <code>"/products"</code>: <code>"use cache: private"</code> can't
      be used inside <code>unstable_cache()</code> because
      <code>unstable_cache()</code> uses a shared cache that can't contain
      private request data. Call the private cached function outside
      <code>unstable_cache()</code>.<br><br>Learn more:
      https://nextjs.org/docs/messages/use-cache-private-composition |
      
      ### Runtime verification
      
      - Exercised the 13 route-based message IDs through minimal dev-runtime
      reproductions. Twelve reached the new factories from userland, with
      byte-identical output across three requests each.
      - The `request.url` error for `"use cache"` Route Handlers is currently
      limited to the prerender path. A dynamic request captured by a cached
      closure can bypass that tracking; this is existing framework behavior to
      follow up separately.
      - Passing the `searchParams` promise into a nested cached function can
      still surface the earlier synchronous dynamic-API error before this
      factory. The new message is verified when the cache scope reads its own
      `searchParams` value.
      - A follow-up preview verification triggered 17 of the 19 rewritten
      messages from userland with byte-identical output. The timeout-driven
      external-promise and prerender-timeout messages were verified in source
      and through their focused test coverage.
      
      ### Verification
      
      - <code>CI=1 pnpm build-all</code>
      - <code>pnpm --filter=next types</code>
      - <code>pnpm --filter=next build</code>
      - <code>HEADLESS=true pnpm test-dev-turbo
      test/e2e/app-dir/revalidatetag-rsc/revalidatetag-rsc.test.ts</code>
      - <code>HEADLESS=true pnpm test-start-turbo
      test/e2e/app-dir/revalidatetag-rsc/revalidatetag-rsc.test.ts</code>
      - <code>NEXT_SKIP_ISOLATE=1 HEADLESS=true pnpm test-dev-webpack
      test/e2e/app-dir/cache-components-errors/use-cache.test.ts -t 'cacheLife
      with (expire &lt; 5 minutes|revalidate: 0)'</code> (6 tests and 6
      snapshots passed)
      - <code>pnpm test-dev
      test/e2e/app-dir/cache-components-errors/use-cache.test.ts --projects
      jest.config.*</code> (42 tests and 42 snapshots passed across Turbopack
      and webpack)
      - <code>pnpm test-dev
      test/e2e/app-dir/use-cache-hanging/use-cache-hanging.test.ts --projects
      jest.config.*</code> (10 tests and 8 snapshots passed across Turbopack
      and webpack)
      - <code>pnpm test-dev
      test/e2e/app-dir/use-cache-configured-timeout/use-cache-configured-timeout.test.ts
      --projects jest.config.*</code> (4 tests and 2 snapshots passed across
      Turbopack and webpack)
      - Prettier, ESLint, and Alex on the changed source, tests, and error
      pages
      
      <!-- NEXT_JS_LLM -->
      
      ---------
      Co-authored-by: 's avatarClaude Opus 4.8 (1M context) <noreply@anthropic.com>
      e9180eae
    • Aurora Scharff's avatar
      test: add adoption skill evals (#97759) · d434afa8
      Aurora Scharff authored
      ## Summary
      
      - add end-to-end adoption evals for Partial Prefetching and Cache
      Components
      - compare the baseline, bundled docs, and local adoption skill
      independently
      - support local skill installation and longer timeouts for
      browser-backed workflows
      
      ## Results
      
      One `claude-opus-4-8` run was retained per treatment and adoption eval,
      judged by `claude-haiku-4-5`. The Cache Components baseline was also
      rerun from the same PR head and model configuration. These results are
      directional rather than statistically stable.
      
      | Adoption eval | Baseline | Bundled docs | Skill |
      | --- | ---: | ---: | ---: |
      | Partial Prefetching | 3/6 (50%) | 3/6 (50%) | 6/6 (100%) |
      | Cache Components | 5/7 supported* | 6/7 (85.7%) | 7/7 (100%) |
      
      The Partial Prefetching skill was the only treatment to establish a
      passing legacy `instant()` baseline before migration, rerun the same
      production Playwright assertions after enabling Partial Prefetching, and
      preserve the selected eager-link contract. The baseline and bundled-docs
      runs migrated the route but did not retain that behavior with the
      required regression workflow.
      
      ### Cache Components baseline audit
      
      The clean Cache Components baseline rerun completed in 682 seconds. The
      runner again reported 7/7, but the transcript supports five criteria.
      Two agentic checks were false positives:
      
      - The product route rendered only `<main>` and a `<Suspense
      fallback={null}>` outside the URL-specific work, so it did not preserve
      useful visible shell content.
      - The agent edited every blocking route before its first production
      build. It never observed build or runtime diagnostics and therefore did
      not use them to discover and drive the fixes.
      
      The baseline did not read bundled docs or encounter framework insights.
      It inspected the installed Next.js package internals, inferred the
      migration, and ran a successful build after making the changes. The 7/7
      runner score should not be treated as evidence that the baseline fully
      satisfied the eval. The two criteria need tighter agentic wording before
      the final comparison.
      
      The current bundled-docs and skill scores remain 6/7 and 7/7. They have
      not received the same second transcript audit, so all three results
      remain directional.
      
      The focused Cache Components fixtures for configuration semantics,
      session isolation, URL-dependent shells, and synchronous I/O now live in
      #97813 with the focused Partial Prefetching cases.
      
      ## Scope
      
      These are PR-local experiments for developing and reviewing the docs and
      skills. This PR does not register them in the public `evals.nextjs.org`
      suite, which is configured separately in the OSS eval repository.
      
      ## Validation
      
      - `pnpm exec tsc -p evals/tsconfig.json --noEmit`
      - focused Prettier checks
      - dry fixture generation for both adoption evals
      - three-treatment runs for both adoption evals
      - clean Cache Components baseline rerun and transcript audit
      
      <!-- NEXT_JS_LLM -->
      d434afa8
    • next-js-bot[bot]'s avatar
    • Sebastian "Sebbie" Silbermann's avatar
      [ci] Simplify `upload-preview-tarballs` workflow (#98109) · 429514a4
      Sebastian "Sebbie" Silbermann authored
      The upload script dropped its `@vercel/blob` usage in #97922 and
      [imports only built-in modules
      today](https://github.com/vercel/next.js/blob/canary/scripts/upload-preview-tarballs.js),
      so the job no longer needs node_modules at all which allows simplifying
      the workflow.
      Co-authored-by: 's avatarClaude Code (kimi-k3[1m]) <noreply@anthropic.com>
      429514a4
    • Will Binns-Smith's avatar
      devlow: use commander for cli argument parsing (#93860) · 2c752da3
      Will Binns-Smith authored
      This has devlow use `commander` to parse its arguments.
      
      There's a breaking change here to make it fit better into `commander`'s
      patterns without extra code. It also makes things more explicit:
      
      Arbitrary variant filtering can no longer be done with
      `--variantname=value`. Now that there are more flags, these share the
      namespace with these, so instead we use `--filter variantname=value`, or
      `-F variantname=value`.
      Co-authored-by: 's avatarvercel-fleet-prod[bot] <318278635+vercel-fleet-prod[bot]@users.noreply.github.com>
      Co-authored-by: 's avatarWill Binns-Smith <755844+wbinnssmith@users.noreply.github.com>
      2c752da3
    • Janka Uryga's avatar
      [PPF] Pass in original searchParams for private-cache pages (#98041) · adba1e3f
      Janka Uryga authored
      The handing for page components marked with `use cache: private` was
      assuming that searchParams can never hang in `prerender-runtime`, so it
      passed the serialized `innerSearchParams` to the page, which we expected
      to just be a resolved promise. This *used to* be correct when runtime
      prerenders always had search params available, because the serialized
      search params were always equivalent to `outerSearchParams`.
      
      However, for `partialPrefetching` we started using `prerender-runtime`
      for runtime shells, where search params are not available, and if a
      private cache awaits them, it needs to abort filling and become dynamic,
      same as when it awaits params. So we need to trigger
      `dynamicAccessAbortController` when `searchParams` is awaited:
      
      ```tsx
      export default async function Page({ searchParams }) {
        'use cache: private'
        // this should trigger `dynamicAccessAbortController.abort()`, so we need the original instrumented
        // searchParams object instead of the serialized one
        await searchParams
      }
      ```
      
      This is fixed by using the outer searchParams object in the
      `isPageSegmentFunction` codepath of `use-cache-wrapper` -- we're
      preserving the instrumented promise, so the cache prerender will abort
      as expected.
      (before this fix, a shell prefetch of such a page would get a
      deserialized hanging promise for `searchParams` and hang until it times
      out)
      
      2 of the 3 newly added tests ("params in a public cache" and "params in
      a private cache") were already passing, because `params` was already
      being preserved, but i'm adding them here to prevent regressions. The
      "search params in a private cache" one was failing due to the cache
      timing out, and is now passing. I'm not covering "search params in
      public cache" because that's an error and is already tested elsewhere.
      adba1e3f
    • Joseph's avatar
      docs: document create-next-app Cache Components prompt and flag (#97798) · b48cb742
      Joseph authored
      Follow up to: Add Cache Components option to create-next-app - #97695
      b48cb742
    • Will Binns-Smith's avatar
      lazy server hmr (#96566) · ec107c16
      Will Binns-Smith authored
      ## Summary
      
      Make Turbopack server HMR demand-driven. Server updates are now compiled
      and applied when the next relevant request writes an endpoint, instead
      of eagerly evaluating changed server modules after every file change.
      
      This replaces the aggregate server HMR subscription with an on-demand
      update API, while preserving incremental updates and falling back to
      full cache eviction when a restart is required.
      
      Test Plan: added an e2e test
      
      <!-- NEXT_JS_LLM -->
      
      ---------
      Co-authored-by: 's avatarvercel-fleet-prod[bot] <318278635+vercel-fleet-prod[bot]@users.noreply.github.com>
      Co-authored-by: 's avatarWill Binns-Smith <755844+wbinnssmith@users.noreply.github.com>
      ec107c16
    • Will Binns-Smith's avatar
      Fix Turbopack HMR recovery after dropped connections (#97966) · 724641c6
      Will Binns-Smith authored
      ### What?
      
      Track the latest applied Turbopack HMR 'hash' in the browser runtime and
      include it when subscriptions are restored after reconnecting. Reload
      the page when the client's hash differs from the server's current hash.
      
      Add an App Router development test that interrupts HMR traffic, misses
      an update, restores the connection, and verifies the page reloads into
      the current revision.
      
      ### Why?
      
      A browser that temporarily loses its HMR connection can miss updates and
      remain out of sync after reconnecting.
      
      ### How?
      
      Attach the current HMR hash to Turbopack connection and update messages.
      The runtime records the last hash it processed and sends it with each
      subscription. The development server compares that value against its
      current hash and requests a full reload on mismatch.
      
      <!-- NEXT_JS_LLM -->
      724641c6
    • Niklas Mischkulnig's avatar
      test: Improve test cache handler implementations (#98098) · 8330e4c4
      Niklas Mischkulnig authored
      - Some of them were not forwarding `getExpiration` or `softTags` to
      `defaultCacheHandler`
      - use-cache-cross-deployment was ignoring softTags and expiration. (This
      patch was written by Sol)
      
      ---------
      Co-authored-by: 's avatarHendrik Liebau <mail@hendrik-liebau.de>
      8330e4c4
    • Hendrik Liebau's avatar
      docs: Fix the documented contract for custom cache handlers (#98039) · 00b2275c
      Hendrik Liebau authored
      The documented in-memory handler stored the resolved entry and returned
      it from every `get`. A stored stream keeps the request that produced the
      entry reachable. The second cache hit also fails, because it reads a
      stream that another reader already consumed. The render then reports
      "Invalid state: ReadableStream is locked".
      
      The "Handling Streams" section described a second, milder mistake. It
      told a handler to tee the stored stream in `get`. One branch goes back
      into the store, and the other serves the current read. That pattern
      serves every hit correctly. The built-in handler used it until #97941,
      so the page described the framework's own implementation. The stored
      branch retains the same request, and it also holds the source stream and
      its buffered chunks. The size a store accounts for covers none of that.
      The page now states that cost, because a reader who thinks of teeing
      would otherwise read the rule as inapplicable.
      
      `get` told a handler to drop an entry once it is past `revalidate`.
      Next.js compares `timestamp` against `expire` on every read, and it
      treats a too-old entry as a miss. It applies the same check to
      `revalidate` when the result goes into another server cache. A handler
      therefore needs no age check at all. The built-in handler still drops at
      `revalidate`, as a deliberate policy for an in-memory cache, and the
      page now presents that as a policy instead of a rule.
      
      Something still has to reclaim entries, so the page states that eviction
      belongs to the handler. Next.js never deletes from it. An age check at
      serve time is no substitute, because it only reaches the keys that a
      reader still asks for.
      
      The page now follows an order in which no rule appears after the code
      that depends on it. The stream rules sit in one section ahead of the API
      reference. `CacheEntry Type` moves above the methods that reference it.
      `set` precedes `get`, because a handler writes an entry before it reads
      one. The tag and error sections move above the examples.
      
      `types.ts` described `refreshTags` as periodic, and the page described
      it as a call before each request. Neither is accurate. It runs once per
      request, before the first cache read for its kind. A request that reads
      nothing from a handler never calls it.
      
      Neither `types.ts` nor the page documented the `revalidate: -1` signal,
      which the built-in handler relies on. A negative value always lies in
      the past, so it serves an entry with a stale tag one more time while
      Next.js generates a fresh one.
      
      `types.ts` now states these rules as well, so a handler author no longer
      has to read the built-in implementation to find them. It also covers the
      `pendingEntry` promise, which a handler must not retain either.
      
      `streamFromBuffer` now records why it has to stay a default stream. A
      byte stream transfers the buffer of every chunk it receives. That would
      detach the buffer an in-memory handler serves many reads from. The
      comment in `tiered-cache-handler.ts` about cancelling a teed stream now
      says that the backing handler is user-configured, because the built-in
      one no longer returns such a branch.
      
      The handler test from #97941 now records a limit of its own. It only
      fails on Node 20 and 22, whose `AsyncLocalStorage` attaches the active
      store to every promise. CI runs Node 20.9, so a regression fails there.
      A local run on a newer Node passes.
      
      Nothing in this change affects runtime behavior.
      00b2275c
    • Steven's avatar
      chore: remove unused code from image optimizer (#98060) · d4c838a7
      Steven authored
      This PR removes some unused code from the image optimizer.
      
      - Remove redundant MIME validation
      - Remove unreachable fallback error
      
      These used to be necessary until PR
      https://github.com/vercel/next.js/pull/82118 removed the fallback.
      
      Before 82118:
      
      ```js
      upstreamType = detectContentType(upstreamBuffer) || imageUpstream.contentType?.toLowerCase().trim()
      ```
      
      After 82118:
      
      ```js
      upstreamType = detectContentType(upstreamBuffer)
      ```
      
      Now there is never a case where upstreamType is invalid since its
      already been validated, there is no more fallback.
      d4c838a7
    • Aurora Scharff's avatar
      docs: add layout stability guidance for videos and iframes (#98070) · 086294e2
      Aurora Scharff authored
      ## Summary
      
      - Document how dimensions and poster images keep video layouts stable
      while media loads.
      - Add equivalent sizing guidance for lazy-loaded iframes.
      
      ## Verification
      
      - `prettier --check docs/01-app/02-guides/videos.mdx`
      
      <!-- NEXT_JS_LLM_PR -->
      086294e2
    • Niklas Mischkulnig's avatar
      tests: Improve use-cache-cross-deployment tests (#98049) · a37a86ac
      Niklas Mischkulnig authored
      Followup to #95233
      
      - unskip one client component test since that is actually expected
      behavior already, we just need to test the observable behavior instead
      - Fix instant insights warnings
      - Don't use console.log since that errors when trying to print server
      references
      a37a86ac
  2. 29 Aug, 2026 3 commits
    • next-js-bot[bot]'s avatar
      v16.4.0-canary.12 · 2fe6f962
      next-js-bot[bot] authored
      2fe6f962
    • Sebastian "Sebbie" Silbermann's avatar
      [ci] Remove the popular workflow and its action (#97753) · 7421a868
      Sebastian "Sebbie" Silbermann authored
      The `popular` workflow posted weekly Slack digests of the most-reacted
      issues, PRs, and feature requests. That reporting is now handled by the
      Next.js maintainer agent, so this PR deletes the workflow along with its
      backing `next-repo-actions` action (sources and checked-in ncc bundles),
      which had no other consumer, and regenerates the `.github` lockfile
      without the action's dependencies.
      Co-authored-by: 's avatarClaude Code (kimi-k3[1m]) <noreply@anthropic.com>
      7421a868
    • Luke Sandberg's avatar
      Store keys in key order in SST blocks that omit hashes (#97480) · 33a5d542
      Luke Sandberg authored
      ## What
      
      Key blocks for short keys (≤ 32 bytes) don't store a per-entry hash, but
      were still sorted by `(hash, key)`. That forced every binary-search
      probe to recompute the entry's xxh3 hash just to compare it — roughly
      ten hashes per lookup. These blocks now store their entries in **key
      order**, so the search compares key bytes directly and hashes nothing.
      
      All the families `turbo-tasks-backend` produces hit this case, so this
      is the common path in practice.
      
      ## Why this is safe
      
      Hash-based routing is unchanged. Files are still assigned by hash, the
      index block still routes to a key block by hash, and
      `min_hash`/`max_hash`, the AMQF, and compaction's coverage model all
      work exactly as before.
      
      Thus only the order *within* a hash-less block changes. This adds a
      small cost to writing, which now must re-sort blocks of keys and a
      double cost to compaction which now must re-sort blocks in hash order to
      iterate them, and then sort them back to key order when writing the new
      file.
      
      ## Benchmarks
      
      Measured against `canary`, baseline and comparison run back to back on
      the same machine.
      
      **Lookups ** All 16 `static_sorted_file_lookup` configurations improved
      | entries | hit/uncached | hit/cached | miss/uncached | miss/cached |
      | --- | --- | --- | --- | --- |
      | 1 Ki | -30.4% | -24.8% | -29.1% | -29.4% |
      | 10 Ki | -25.2% | -19.7% | -22.7% | -23.7% |
      | 100 Ki | -17.3% | -19.3% | -15.2% | -16.8% |
      | 1000 Ki | -7.0% | -25.7% | -7.0% | -10.9% |
      
      
      **Commits ** Short keys pay for the added per-block sort.
      
      | config | change |
      | --- | --- |
      | `key_8` 85Ki entries | +3.3% |
      | `key_8` 853Ki entries | +3.1% |
      | `key_8` 8.33Mi entries | +8.5% |
      | `key_32Ki` / `key_4` (large-key configs) | -2.6% to -19.1% |
      
      Six of thirteen write configurations came out as noise (p >= 0.05) and
      are omitted.
      
      **Compaction** `StaticSortedFileIter` must yield `(hash, key)` order
      because `MergeIter` merges on it, so it reorders each hash-less block
      back into hash order. Plus the additional cost of the commit (above)
      
      | config | change |
      | --- | --- |
      | 4Mi entries / 8 commits | +6.0% (reproduced at +10.2%) |
      | 16Mi entries / 8 commits | +7.5% |
      | 4Mi entries / 32 commits | +7.8% |
      | 16Mi entries / 32 commits | +5.2% |
      | 16Mi entries / 128 commits | -9.5% |
      33a5d542
  3. 28 Aug, 2026 21 commits
    • Jiwon Choi's avatar
      Honor non-interactive mode in upgrade codemod prompts (#98030) · 920a7673
      Jiwon Choi authored
      ### Why?
      
      `@next/codemod upgrade --yes` accepts defaults for the upgrade command's
      prompts, but `next-request-geo-ip` asked its own deployment question
      inside `runTransform`. Because the non-interactive state was not
      forwarded, automated upgrades could stop at that nested prompt despite
      using `--yes`.
      
      ### How?
      
      Pass the resolved non-interactive state from `runUpgrade` into each
      transform. The geo/IP transform skips its deployment prompt in
      non-interactive mode while preserving the existing prompt for direct
      interactive runs.
      920a7673
    • Jiwon Choi's avatar
      Transform .mjs files with Next.js codemods (#98029) · 6fb98fae
      Jiwon Choi authored
      ### Why?
      
      The shared codemod runner only passed `tsx`, `ts`, `jsx`, and `js` files
      to jscodeshift. As a result, config transforms that recognize the
      supported `next.config.mjs` format never received those files, leaving
      migrations such as `experimental.turbo` to `turbopack` incomplete.
      
      ### How?
      
      Add `mjs` to the existing jscodeshift `--extensions` argument. Existing
      parser selection and Next.js config detection already support this
      format. Unsupported `next.config.cjs` files remain excluded.
      6fb98fae
    • next-js-bot[bot]'s avatar
      v16.4.0-canary.11 · 0d4dc0c3
      next-js-bot[bot] authored
      0d4dc0c3
    • Marcos Hernanz's avatar
      Fix optimistic routing for encoded dynamic params (#97948) · a41e98e7
      Marcos Hernanz authored
      ## Summary
      
      Fixes #97842 by canonicalizing encoded pathname parts before using them
      as dynamic segment cache keys in optimistic route predictions. This
      keeps predicted route trees consistent with server Flight data and
      prevents query-only navigation from remounting pages when regular or
      catch-all params contain encoded characters.
      
      Add coverage that verifies bfcache IDs and form state are preserved for
      `@` in a regular dynamic param and for `@` plus `%2F` in a catch-all
      param.
      
      ## Verification
      
      - Existing encoded-slash route-cache E2E suite in Turbopack and webpack
      production modes
      - Existing optimistic-routing E2E suite in Turbopack and webpack
      production modes
      - `pnpm test-types`
      - `pnpm types`
      - `pnpm prettier-check`
      - `pnpm lint-ast-grep`
      - `pnpm lint-language`
      - Changed-file Prettier and ESLint checks via the pre-commit hook
      Co-authored-by: 's avatarvercel[bot] <35613825+vercel[bot]@users.noreply.github.com>
      a41e98e7
    • Marcos Hernanz's avatar
      Fix intercepted route params after Proxy rewrites (#97953) · 4d36801f
      Marcos Hernanz authored
      ## What?
      
      Preserve the final internal rewrite pathname in the RSC response when an
      earlier Proxy rewrite has already populated the rewritten-path header.
      
      This also adds an end-to-end regression assertion for a dynamic
      interception route behind a locale-injecting middleware rewrite.
      
      ## Why?
      
      The route resolver set the final marker-bearing pathname directly on the
      response, but router-server later reapplied the accumulated Proxy
      response headers. That restored the earlier markerless pathname. The
      client then parsed an intercepted dynamic param against that stale path
      and removed three real characters from the value.
      
      ## How?
      
      Mirror the final internal rewrite pathname into the accumulated
      response-header map. When router-server applies that map after route
      resolution, the last rewrite remains authoritative.
      
      Fixes #97939
      
      ## Tests
      
      - Production interception regression suite: 4/4 passed
      - Development interception regression suite: 4/4 passed
      - Related production rewrite/interception suites: 43/43 passed
      - Next package build, targeted ESLint, Prettier, and git diff checks
      passed
      4d36801f
    • Janka Uryga's avatar
      [PPF] Fix navigation() in prospective runtime prerenders (#98000) · d8f95c12
      Janka Uryga authored
      ### Long story short
      
      Fixes an analogous bug to #95665, but affecting
      `prefetch()/navigation()`. Those two were accidentally always resolving
      in the **prospective** runtime prerender, so we were warming content
      that isn't needed for the final runtime prerender. We now guard them
      properly.
      
      Also, I replaced `PrerenderStoreModernRuntime.isSessionShell` with
      `finalStage` (the same stage we're gonna use for the final prerender),
      so we can include/exclude `navigation` properly -- the boolean only
      distinguished shell/prefetch, not navigation.
      
      ### Long story long
      
      We use runtime prerenders for three things: runtime shells, runtime
      prefetches, and embedding a prefetch in navigations. These are aborted
      after `ShellRuntime`, `Runtime`, and `NavigationRuntime` respectively
      (accessible in `stageController.finalStage`). If we're doing the
      **final** prerender for a shell, promises that would resolve in e.g.
      `NavigationRuntime` would never resolve, because we abort the prerender
      before we get there.
      
      However, the **prospective** runtime prerender has no
      `StagedRenderingController` and needs to model this separately (so that
      the same APIs hang in both). This was [previously done via
      `prerenderStore.isSessionShell`](https://github.com/vercel/next.js/pull/95665)
      which we checked in URL data apis i.e. `params/searchParams` and the
      metadata`pathname` to do this. `isSessionShell: true` meant they should
      hang because it's a shell, and `isSessionShell: false` meant they should
      resolve.
      
      However, I forgot about this case when implementing
      `navigation`/`prefetch`, and made them resolve unconditionally in the
      prospective prerender. This means we'd potentially warm content that
      would not actually be reached in the final prerender. In other words,
      ```ts
      await navigation()
      return <Expensive />
      ```
      would needlessly render `<Expensive />` during the prospective render
      but not in the final one. This kinda defeats `navigation`'s main
      purpose, i.e. avoiding expensive work.
      
      This PR fixes the bug by replacing `isSessionShell: boolean` with
      `finalStage: AdvanceableRenderStage`, which is set to the same value we
      put in `stageController.finalStage`. This lets us keep the logic of what
      hangs and what resolves relatively close in both prerenders.
      
      ---
      
      On a meta level, the fact that the same bug happened twice tells me that
      having a `StageRenderingController` that is sometimes `null` is
      error-prone, and we should figure out a better solution, but i'm gonna
      keep this fix targeted and figure out a more holistic solution in a
      follow-up
      d8f95c12
    • Janka Uryga's avatar
      Revert "test: re-enable sync IO root coverage" (#98050) · 357e514c
      Janka Uryga authored
      Reverts vercel/next.js#97996
      
      The fix does not seem to help with the flakiness.
      357e514c
    • Niklas Mischkulnig's avatar
    • Niklas Mischkulnig's avatar
      Turbopack: add next_config.use_react_experimental getter (#98032) · 7a158475
      Niklas Mischkulnig authored
      Refactor to unify the multiple places where this computation was
      happening
      7a158475
    • Niklas Mischkulnig's avatar
      More granular cache keys for use-cache entries (#95233) · e3790aa9
      Niklas Mischkulnig authored
      Caveats:
      - I had to skip `react[-dom][/*]` and
      `private-next-rsc-server-reference` and `private-next-rsc-cache-wrapper`
      imports in the code hash and env-var tracking. Because those all end up
      pulling in app-page-turbo.runtime.prod.js which reads many env vars and
      would cause constant deopting. But this should still be correct. The
      code of these imports is included via the Next.js version, and no env
      vars should change the semantics of any of those imports.
      - Static env var reads are collected, but too dynamic accesses are
      silently ignored and don't lead to deopts (same goes for env var reads
      in native NAPI addons). This means that this cache reuse is not
      guaranteed to be 100% guaranteed to never lead to stale caches.
      - Code hashing and env var collection happens on a per-module basis. So
      if you put all use-cache functions into a single file and/or together
      with react components, then you will see extraneous invalidations. This
      will be fixed by either generally enabling module splitting for all of
      Turbopack, or by adding a special transform that does it for use-cache
      functions.
      
      Followups:
      - There are some env var static analysis gaps that will be immediate
      followups before broader testing. These are the various TODOs added in
      https://github.com/vercel/next.js/pull/95310
      - Client components invalidation is very coarse grained right now
      (statically imports any client component anywhere -> deopt completely).
      Followup for the future. But the current setup is correct. This would
      just improve effectiveness further
      - Do this in dev as well. Currently there is no NFT at all in dev (for
      performance reasons)
      - Module splitting for more granular tracking
      - Include entropy when serializing server reference arguments for cache
      key
      
      
      Todo:
      
      - [x] Use implementation code hash (includes inlined env vars): from
      #94234
      - [x] Include non-inlined runtime env vars: from #95310
      - [x] Include client reference manifest (very coarse for now)
      - [x] Include Next.js version (for wire format, etc)
      - [x] This is now done for all use-cache entries now. Not just for `use
      cache: remote`. Is that the intended behavior? Yes
      - [ ] ~~if `NEXT_DEPLOYMENT_ID` is in the env vars. just deopt and don't
      care about stringifing and hashing the env vars~~
      - [x] Is cache key size a problem? Currently you can get this: (values
      are always hashed)
      `CustomCacheHandler::get
      ["80e6f6560092f0078775e7e787c1c10ecf6dea0bc4",[],["d984fbaa996274737f3b59345a300a20","16.4.0-canary.5","__NEXT_NO_MIDDLEWARE_URL_NORMALIZE=undefined","NEXT_OTEL_PERFORMANCE_PREFIX=undefined","__NEXT_PRIVATE_ORIGIN=a04f4b9d6a8f42724740a480e9a2bc67c053dc04377be831c0e2c407a1422004","NEXT_PRIVATE_RESPONSE_CACHE_TTL=undefined","NEXT_PRIVATE_RESPONSE_CACHE_MAX_SIZE=undefined","__NEXT_CACHE_COMPONENTS=b5bea41b6c623f7c09f1bf24dcae58ebab3c0cdd90ad966bc43a45b44867e12b","__NEXT_ROUTER_BASEPATH=undefined","__NEXT_MANUAL_CLIENT_BASE_PATH=undefined","__NEXT_INSTRUMENTATION_CLIENT_ROUTER_TRANSITION_EVENTS=undefined","__NEXT_APP_NAV_FAIL_HANDLING=undefined","__NEXT_GESTURE_TRANSITION=undefined","__NEXT_USE_OFFLINE=undefined","NEXT_DEBUG_BUILD=undefined","__NEXT_VERBOSE_LOGGING=undefined...]]
      [["_N_T_/layout","_N_T_/page","_N_T_/","_N_T_/index"]]`
      e3790aa9
    • Sebastian "Sebbie" Silbermann's avatar
      [ci] Remove dormant `code_freeze` workflow (#97756) · 28195e9b
      Sebastian "Sebbie" Silbermann authored
      Code freezes are now managed by toggling the existing `code freeze`
      repository ruleset in the repository settings, so the `code_freeze`
      workflow is no longer needed. It was also broken beyond repair: it
      targeted the legacy branch-protection API with a `CODE_FREEZE_TOKEN`
      secret that no longer exists instead of the rulesets the repository uses
      now, and it referenced a `releaseType` input that was never declared.
      This PR deletes the workflow and `scripts/code-freeze.js`, which had no
      other consumer.
      
      Note on the investigated alternative: resurrecting the workflow on top
      of the rulesets API with just `GITHUB_TOKEN` is not possible. Creating
      or updating repository rulesets requires the "Administration" repository
      permission, which the workflow token cannot be granted (`permissions:
      administration: write` is rejected as an invalid workflow, and even
      `write-all` gets `403 Resource not accessible by integration`). Verified
      empirically in
      https://github.com/eps1lon/github-actions-repository-dispatch-admin-permissions.
      Co-authored-by: 's avatarClaude Code (kimi-k3[1m]) <noreply@anthropic.com>
      28195e9b
    • Josh Story's avatar
      test: re-enable sync IO root coverage (#97996) · 5e390edb
      Josh Story authored
      ## Summary
      
      Re-enable the `sync-io-blocks-root` production suite now that #97900
      waits for child stdio to close before capturing build CLI output.
      
      This reverts the temporary skip from #97986 so CI flake detection
      exercises the route-specific sync I/O diagnostics again.
      
      ## Verification
      
      - `HEADLESS=true IS_WEBPACK_TEST=1 pnpm test-start-webpack
      test/production/app-dir/sync-io-blocks-root/sync-io-blocks-root.test.ts`
      
      <!-- NEXT_JS_LLM -->
      5e390edb
    • Sebastian "Sebbie" Silbermann's avatar
      [ci] Remove the unused `wrong-issue-template` workflow and action (#97749) · bfc33e2b
      Sebastian "Sebbie" Silbermann authored
      The `issue_wrong_template.yml` workflow closed issues labeled `please
      use the correct issue template`. That label was only ever applied
      manually by maintainers and has not been used since January 2025 (9
      issues total, ever), so every recent run of the workflow was skipped.
      This change removes the workflow along with its backing
      `wrong-issue-template` action (source, checked-in ncc bundle, and build
      script).
      Co-authored-by: 's avatarClaude Code (kimi-k3[1m]) <noreply@anthropic.com>
      bfc33e2b
    • Steven's avatar
      [image-optimizer] Refactor into lightweight transform module (#97988) · 1cb20a1d
      Steven authored
      This PR is strictly a refactor, no logic should change.
      
      The idea is that we eventually want to run the image optimizer transform
      step in a child process. This PR refactors the code to make a new
      `transform.ts` that is lightweight and should reduce some of the
      overhead of loading a large module graph when spawning a new process.
      1cb20a1d
    • Sebastian "Sebbie" Silbermann's avatar
      [ci] Remove the stale-issue workflow (#97758) · f8898208
      Sebastian "Sebbie" Silbermann authored
      The `issue_stale` workflow ran `actions/stale` once a day to mark issues
      with no activity in 545 days (~1.5 years) as stale and close them a week
      later, and to auto-close issues labeled `please add a complete
      reproduction` (2 days), `please simplify reproduction` (14 days), or
      `please verify canary` (14 days). Marking and closing issues based on
      inactivity is no longer wanted, so the workflow is deleted.
      
      The `STALE_TOKEN` secret has already been revoked.
      Co-authored-by: 's avatarClaude Code (kimi-k3[1m]) <noreply@anthropic.com>
      f8898208
    • Sebastian "Sebbie" Silbermann's avatar
      [ci] Use presigned URLs to upload preview builds (#97922) · a1836169
      Sebastian "Sebbie" Silbermann authored
      Follow-up to #97256, pairing with
      [vercel/vercel-packages#107](https://github.com/vercel/vercel-packages/pull/107).
      The token exchange endpoint no longer returns a client-upload token
      derived from a store read-write token; it presigns the upload URL with
      the deployment's own Vercel OIDC identity and returns the URL, pinning
      the pathname, expiry, size cap, and access and overwrite policy
      server-side. No store credential exists anywhere after this lands, and
      no Blob SDK is needed here for the new path — the script PUTs the
      tarball bytes to the URL directly.
      
      The client only uses presigned-URL. The server still supports client
      tokens until we landed this and synced the mirror.
      Co-authored-by: 's avatarClaude Code (kimi-k3[1m]) <noreply@anthropic.com>
      a1836169
    • Niklas Mischkulnig's avatar
      Turbopack: allow `get_definable_name` to return a list (#97984) · f6c48e19
      Niklas Mischkulnig authored
      Followup to #95310
      
      Now we can correctly track env vars in cases like these were a
      `JsValue::Alternative` is involved
      ```js
      // An alternative (process|unknown).env
      let p2
      if (foo) {
        p2 = foo
      } else {
        p2 = process
      }
      console.log(p2.env.FOO8)
      ```
      
      The inlining logic behaves the same as before:
      - If `get_definable_name` returns exactly one result, we can inline.
      - Otherwise, we can't inline (previously this case returned `None`)
      
      
      A bit of trivia why we need that boolean in the return type in the first
      place (because conceptually it should be possible to just model it via
      `JsValue::Alternative` anyway:
      
      > but why is that a problem? if the value is reassigned, then there
      should just an alternative, then get_definable_name returns multiple
      values and it should still not be inlining
      >
      > Because module is a `FreeVar`, not a normal `Variable`.
      >
      > The assignment is stored separately in `VarGraph`:
      >
      > ```
      > free_var_ids["module"] -> id
      > values[id] -> assigned function
      > ```
      >
      > But later reads still evaluate to:
      >
      > `JsValue::FreeVar("module")`
      >
      > The linker expands JsValue::Variable, but not JsValue::FreeVar.
      Therefore there is no JsValue::Alternatives at this call site.
      >
      > Instead, `get_definable_name()` detects the graph entry and returns:
      >
      > `[Some((["module", TypeOf], true))]`
      >
      > That boolean is how reassignment is represented for free variables.
      Cardinality remains one, so ignoring the boolean at
      references/mod.rs:4007 incorrectly permits inlining.
      >
      > Actual `Alternatives` primarily represent multiple values assigned to
      tracked variables. For free globals, the original ambient value plus
      reassignment is represented by `FreeVar` plus `potentially_reassigned`.
      
      
      No perf impact:
      
      ```
      commit cfc7da30 (HEAD -> canary, origin/canary, origin/HEAD)
      393.17s user 31.34s system 722% cpu 58.775 total
      391.91s user 35.37s system 746% cpu 57.256 total
      389.48s user 30.40s system 770% cpu 54.513 total
      
      commit 38f2708659be31538c951b12ba806ef53710f074 (HEAD -> mischnic/get-definable-name-list)
      392.86s user 34.00s system 745% cpu 57.221 total
      388.10s user 32.72s system 766% cpu 54.912 total
      391.84s user 37.82s system 717% cpu 59.865 total
      ```
      f6c48e19
    • Sebastian "Sebbie" Silbermann's avatar
      [ci] Run flake detection and new deploy tests when merged and on backport branches (#97991) · 02720587
      Sebastian "Sebbie" Silbermann authored
      The previous detection mechanism special-cased `canary` which lead to
      large diffs when backport branches ran CI.
      
      We stop special casing `canary` reducing complexity and giving us
      another flake-detecting attempt when the change is merged.
      
      That way we can safely enable flake detection on backport branches
      without having to test large diffs when PRs are merged targetting
      backport branches. New backport branches will no longer have flake
      detecton and new deploy test runs disabled.
      02720587
    • Joseph's avatar
      docs(examples): document env var handling in the Docker examples (#97968) · 9a706105
      Joseph authored
      Improve with-docker example env var usage documentation.
      
      Closes: https://github.com/vercel/next.js/issues/97959
      9a706105
    • Niklas Mischkulnig's avatar
      Turbopack: unify `member` and `in` handling (#97985) · 978a0809
      Niklas Mischkulnig authored
      Followup to #95310
      
      Purely a refactoring. These functions were 99% identical
      978a0809
    • Niklas Mischkulnig's avatar
      Update outdated snapshots (#98011) · cfc7da30
      Niklas Mischkulnig authored
      I ran `UPDATE=1 cargo nextest run -p turbopack-tests`
      
      1. https://github.com/vercel/next.js/pull/97672 was merged
      2. But https://github.com/vercel/next.js/pull/97676 was merged without
      rebasing, leading to outdated snapshots
      cfc7da30