1. 17 Feb, 2026 2 commits
    • nextjs-bot's avatar
      v16.2.0-canary.48 · 537da8bd
      nextjs-bot authored
      537da8bd
    • Josh Story's avatar
      Use StageController for runtime prerendering (#89972) · e5e0d356
      Josh Story authored
      Stacked on #89971
      
      This controller was introduced to help with dev time validation. It
      models stage transitions in a helpful way that will become more useful
      soon as we get more advanced with what kinds of sync IO are considered
      errors.
      
      To prepare for this we will update the implementation to use the stage
      controller for build and runtime prerendering not just dev
      
      We don't yet use it for static prerendering because that one is so
      simple and there is really no stage beyond the first one and then an
      abort so we will keep it as is
      
      Additionally, the private cache store no longer has the
      `runtimeStagePromise`. when you first enter this store type during a
      runtime prerender we wait until the outer store's runtime stage has
      begun. Previously the proimse signifying this stage transition was
      included in the private cache store itself so nested caches could
      similarly wait, however you can't actually get to a nested cache until
      after it is resolved b/c the outermost one blocks.
      e5e0d356
  2. 16 Feb, 2026 10 commits
    • JJ Kasper's avatar
      Always set adapter deploy env variable (#90064) · 960437cf
      JJ Kasper authored
      This ensures we always set this env variable so that it overrides any
      flag opt ins when we specifically want to test with or without the
      adapter.
      960437cf
    • JJ Kasper's avatar
      Expand deferred entries test suite and fix turbopack build (#90057) · 6144980c
      JJ Kasper authored
      ## Summary
      Reworks Turbopack deferred entries in production build so deferred
      routes are processed last in the same project lifecycle, with
      `onBeforeDeferredEntries` executed between the non-deferred and deferred
      phases.
      
      ## What changed
      - Moved deferred build phasing into Rust in
      `project_write_all_entrypoints_to_disk`:
        - non-deferred phase
        - `onBeforeDeferredEntries`
        - deferred phase
      - Kept callback invocation on the Rust side via the existing node-worker
      callback plumbing.
      - Narrowed invalidation after `onBeforeDeferredEntries` to deferred app
      source subtrees instead of invalidating the whole project filesystem
      cache.
      - Added `DiskFileSystem::invalidate_path_and_children_with_reason(...)`
      in `turbo-tasks-fs`.
      - Derived deferred invalidation dirs from deferred routes’
      `original_name` values.
      - Retained a full-invalidation fallback only when app-dir path
      resolution is unavailable.
      - Deferred route selection still includes both app pages and app route
      handlers.
      
      ## Validation
      - `cargo check -p next-napi-bindings -p turbo-tasks-fs`
      - `pnpm test-start-turbo
      test/e2e/deferred-entries/deferred-entries.test.ts` (21/21 passing)
      - Validated against [workflows
      repo](https://github.com/vercel/workflow/pull/1058) and v0
      6144980c
    • JJ Kasper's avatar
      test: scope e2e timeouts to startup and per-it (#89929) · f8e47d49
      JJ Kasper authored
      This aims to avoid us having tests stall for upwards of 240s when a
      single assertion in the test stalls. This is very common currently. To
      also avoid wasting the entire time of resetting the test suite this also
      allows 1 retry for individual failed assertions. This won't always work
      since some assertions rely on previous setup so this also keeps the
      entire test suite retry handling as a fallback.
      
      This change is not applied for dev tests as they check HMR and compile
      lazily.
      
      ## Summary
      - keep elevated Jest timeout for test setup/startup in e2e-utils
      - enforce a 60s default timeout for individual `it`/`test` cases
      - apply one retry per individual test via `jest.retryTimes(1)`
      
      ## Verification
      - pnpm testonly test/development/gssp-notfound/index.test.ts
      - pnpm testonly test/development/enoent-during-require/index.test.ts
      - pnpm testonly test/e2e/custom-app-render/custom-app-render.test.ts
      
      Tested against our deploy tests to see if this helps:
      
      Current run
      [21967823508](https://github.com/vercel/next.js/actions/runs/21967823508)
      
      Jobs: 24 (with test-runner output: 20)
      Whole-suite retry starts: 11 (retry 1: 8, retry 2+: 3)
      Jobs that needed suite retries: 8
      Unique test files retried: 7
      
      Previous run
      [21964085768](https://github.com/vercel/next.js/actions/runs/21964085768)
      
      Jobs: 26 (with test-runner output: 20)
      Whole-suite retry starts: 18 (retry 1: 13, retry 2+: 5)
      Jobs that needed suite retries: 9
      Unique test files retried: 12
      f8e47d49
    • Andrew Clark's avatar
      Ignore `prefetch={true}` on Links to routes with `instant` (#90061) · 5aa4568b
      Andrew Clark authored
      When a route has `unstable_instant` defined on any segment, setting
      `prefetch={true}` on a Link to that route is now a no-op. The prefetch
      behaves the same as the default auto strategy — cached content is
      prefetched but dynamic content is deferred to navigation time.
      
      A full static prefetch doesn't make sense for routes with instant
      configs, since those segments use runtime prefetching. Rather than
      silently doing something the developer didn't intend, we ignore the prop
      entirely.
      
      To detect this on the client, the server now sends a bitmask instead of
      a boolean for the per-segment prefetch metadata. One bit tracks whether
      the subtree contains any instant config, which propagates up so the
      client can check it at the root without traversing.
      5aa4568b
    • nextjs-bot's avatar
      v16.2.0-canary.47 · 24e36901
      nextjs-bot authored
      24e36901
    • Jude Gao's avatar
      [Docs] Add AGENTS.md and bundled docs guide (#89973) · 104f0db3
      Jude Gao authored
      Adds a guide for configuring AI coding agents to use the version-matched
      documentation bundled in `node_modules/next/dist/docs/` (shipped via the
      `copy_docs` build task in #89850) instead of stale training data.
      
      The guide covers how the bundled docs work, the `AGENTS.md` and
      `CLAUDE.md` files generated by `create-next-app --agents-md`, and how to
      add project-specific instructions outside the `<!--
      BEGIN:nextjs-agent-rules -->` markers.
      104f0db3
    • Jimmy Lai's avatar
      docs: agent skills, pr-status script, and AGENTS.md updates (1/8) (#89857) · a04d598f
      Jimmy Lai authored
      ## Summary
      
      - **Agent skills**: 9 new skill files in `.agents/skills/` covering DCE,
      flags, react-vendoring, runtime-debug, PR triage, and skill authoring
      - **PR status tooling**: `scripts/pr-status.js` script and
      `.claude/commands/pr-status.md` command
      - **AGENTS.md**: updated with skill references and development
      guidelines
      
      ## Test plan
      
      - [ ] No runtime behavior changes
      - [ ] Docs and tooling only
      
      ---------
      Co-authored-by: 's avatarTim Neutkens <tim@timneutkens.nl>
      a04d598f
    • Swarnava Sengupta's avatar
      docs: clarify async instrumentation register request (#90039) · ababa1b3
      Swarnava Sengupta authored
      Explicitly document that Next.js waits for an async instrumentation
      register function to complete before handling incoming requests, and
      align wording between the guide and API reference.
      
      ---------
      Co-authored-by: 's avatarCursor <cursoragent@cursor.com>
      Co-authored-by: 's avatarJoseph <joseph.chamochumbi@vercel.com>
      ababa1b3
    • Jiwon Choi's avatar
      fix(turbopack): --debug-build-paths fails with route groups (#89336) · 80e849e1
      Jiwon Choi authored
      Confirmed the fix locally on the original app I faced the issue with.
      
      ### Why?
      
      When using `--debug-build-paths`, a pattern with a route group on
      Turbopack, it fails with an error:
      
      ```
      Error [PageNotFoundError]: Cannot find module for page: /nested
          at ignore-listed frames {
        code: 'ENOENT'
      }
      ```
      
      Current Behavior:
      https://github.com/vercel/next.js/actions/runs/21544427008/job/62083680496?pr=89336#step:35:459
      
      The bug lives in `crates/next-api/src/project.rs`, specifically in
      `from_debug_build_paths()`. This function is responsible for deriving
      route paths from debug build inputs, but it currently preserves route
      groups when it shouldn’t.
      
      With the current behavior, an input like `app/(group)/nested/page.tsx`
      produces the output `/(group)/nested`. In other words, the route group
      segment is kept in the generated path.
      
      However, Turbopack route keys explicitly strip route groups. In
      `next-core/src/next_app/mod.rs`, the conversion from `AppPage` to
      `AppPath` removes route group segments. For the same input, Turbopack
      expects the route key to be `/nested`, not `/(group)/nested`.
      
      This mismatch causes a downstream failure. `from_debug_build_paths()`
      produces `/(group)/nested`, while the Turbopack route key is `/nested`.
      Since `should_include_app_route()` relies on an exact string match, the
      comparison fails. As a result, the route is excluded, the module is
      never compiled, and the error ultimately surfaces as a
      `PageNotFoundError`.
      
      ### How?
      
      Strip route group `(xxx)` and parallel route `@xxx` segments in
      `from_debug_build_paths()` to match how Turbopack normalizes route keys.
      
      ---------
      Co-authored-by: 's avatarNiklas Mischkulnig <4586894+mischnic@users.noreply.github.com>
      80e849e1
    • Niklas Mischkulnig's avatar
  3. 14 Feb, 2026 7 commits
  4. 13 Feb, 2026 21 commits
    • nextjs-bot's avatar
      v16.2.0-canary.45 · bd473d00
      nextjs-bot authored
      bd473d00
    • Benjamin Woodruff's avatar
      chore: Don't run build-and-deploy CI job on graphite-base branches (#89982) · 6f94c012
      Benjamin Woodruff authored
      We don't need/want preview builds for these base branches, it's a waste
      of CI capacity.
      
      Relevant docs:
      https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#onpushbranchestagsbranches-ignoretags-ignore
      
      > Use the branches filter when you want to include branch name patterns
      or when you want to both include and exclude branch names patterns. Use
      the branches-ignore filter when you only want to exclude branch name
      patterns. You cannot use both the branches and branches-ignore filters
      for the same event in a workflow.
      
      > If you define only tags/tags-ignore or only branches/branches-ignore,
      the workflow won't run for events affecting the undefined Git ref. If
      you define neither tags/tags-ignore or branches/branches-ignore, the
      workflow will run for events affecting either branches or tags.
      6f94c012
    • nextjs-bot's avatar
      v16.2.0-canary.44 · 1ea3233a
      nextjs-bot authored
      1ea3233a
    • Hendrik Liebau's avatar
      Run fast immediates during prerender abort to fix flaky I/O stack traces (#89969) · e0668e46
      Hendrik Liebau authored
      Follow-up for #89834.
      
      In `prerenderAndAbortInSequentialTasks`, React's `finishHalt` (scheduled
      via `setImmediate` from `abort()`) could race with the component's
      pending `setTimeout` callback. When both ended up in the same timer
      phase, the component timer would fire after `abort()` but before
      `finishHalt`, linking the async graph and producing the more precise
      `await` location (21:9). When `finishHalt` won the race, it read an
      unlinked graph and fell back to the function declaration (20:16).
      
      Adding `DANGEROUSLY_runPendingImmediatesAfterCurrentTask()` to the abort
      task captures `finishHalt` as a fast immediate, ensuring it runs right
      after `abort()` before any other timers. This makes the result
      deterministic at the cost of always producing the less precise stack
      frame (function declaration instead of `await` expression). The resolve
      step is split into a separate task because it needs to wait for the
      abort's fast immediates to complete.
      
      When using `--debug-prerender`, we're also re-adding the hint to run
      `next dev` for even better stack traces, since dev mode can produce the
      precise `await` location by running the render to completion and
      resolving the I/O promises.
      
      [Flakiness
      metric](https://app.datadoghq.com/ci/test/runs?query=test_level%3Atest%20%40git.repository.id%3A%22github.com%2Fvercel%2Fnext.js%22%20%40test.type%3A%22nextjs%22%20%40test.status%3A%22fail%22%20%40test.suite%3A%22Cache%20Components%20Errors%22%20%40git.branch%3Acanary%20-%40ci.pipeline.name%3Atest-e2e-deploy-release&agg_m=count&agg_m_source=base&agg_t=count&currentTab=overview&eventStack=&fromUser=false&index=citest&start=1770404554855&end=1771009354855&paused=false)
      e0668e46
    • JJ Kasper's avatar
      Fix missing incremental cache in middleware unstable_cache (#89980) · 69d63edc
      JJ Kasper authored
      ## Summary
      - pass `IncrementalCache` into the shared middleware template adapter so
      middleware/proxy modules initialize `globalThis.__incrementalCache`
      - add regression coverage for `unstable_cache` usage inside both
      deprecated `middleware` (edge) and `proxy` (node) fixtures
      - verify both e2e suites pass without hitting `Invariant:
      incrementalCache missing in unstable_cache`
      
      ## Verification
      - `pnpm build`
      - `NEXT_SKIP_ISOLATE=1 NEXT_TEST_MODE=dev pnpm testonly
      test/e2e/app-dir/app-middleware/app-middleware.test.ts`
      - `NEXT_SKIP_ISOLATE=1 NEXT_TEST_MODE=dev pnpm testonly
      test/e2e/app-dir/app-middleware-proxy/app-middleware-proxy.test.ts`
      69d63edc
    • JJ Kasper's avatar
      Turbopack hmr: preserve group factory consistency for compressed modules (#89976) · ad7d27ec
      JJ Kasper authored
      ## Summary
      - update `installCompressedModuleFactories` to reuse an existing factory
      in a compressed ID group when filling missing IDs
      - keep `newModuleId` notifications aligned with actual IDs installed
      (`newModuleId(id)`)
      - add an execution regression test for the mixed-group case where one ID
      already has a factory and another is missing
      - regenerate affected runtime snapshots
      (runtime/debug-ids/workers/preset_env)
      
      Aims to fix cases like this being seen recently:
      
      ```sh
      Error: Module 8896 was instantiated because it was required from module 18500, but the module factory is not available.
      ```
      
      ```
      
      ## Test Plan
      - `cargo test -p turbopack-tests --test execution test_tests__execution__turbopack__runtime__factory_group_existing_factory__input__index_js -- --nocapture`
      - `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__runtime__default_build_runtime__input__index_js -- --nocapture`
      - `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__runtime__default_dev_runtime__input__index_js -- --nocapture`
      - `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__debug_ids -- --nocapture`
      - `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__swc_transforms__preset_env__input__index_js -- --nocapture`
      - `cargo test -p turbopack-tests --test snapshot test_tests__snapshot__workers__ -- --nocapture`
      ad7d27ec
    • Benjamin Woodruff's avatar
      Turbopack: Fix flake in task_statistics unit test (#89981) · 6df0b7b9
      Benjamin Woodruff authored
      If we don't explicitly return a `Vc::cell(())` here, then `<() as dyn
      turbo_tasks::vc::default::ValueDefault>::value_default` gets called in a
      non-deterministic way.
        
      That's not something we care about testing here, so just add a an
      explicit `Vc::cell(())` call to avoid it.
      6df0b7b9
    • Josh Story's avatar
      Model abandoning by signal (#89971) · d45f83fb
      Josh Story authored
      Stacked on #89970
      
      The staged rendering class will be used for more soon in more contexts
      (prod prerendering for runtime prefetches for example). This changes the
      interface for render abandonment to not use the presence of the render
      abort signal
      d45f83fb
    • Luke Sandberg's avatar
      [turbopack] use type_ids to register turbo task traits on value types (#89964) · a7f5106f
      Luke Sandberg authored
      Tiny optimization, there is no need to use global names for this usecase and we can save a bit of memory and time.
      a7f5106f
    • Josh Story's avatar
      Rename node extension utils for clarity (#89970) · e6d27d4a
      Josh Story authored
      finding the file with sync IO utils is tricky because it is called
      `utils`. this change gives the file a more clear name.
      e6d27d4a
    • nextjs-bot's avatar
      v16.2.0-canary.43 · ea3e11bc
      nextjs-bot authored
      ea3e11bc
    • Benjamin Woodruff's avatar
      Turbopack: Use `std::any::type_name` for global naming of turbo-task items (#89874) · 14c1f8c6
      Benjamin Woodruff authored
      _I wrote this PR by hand, because I wanted to make sure I got all the details right._  
        
      The previous approach for computing global names was `module path` + `item name`.
      
      Since @lukesandberg added support for inventory, we can now nest `turbo_task::function` and `turbo_task::value` macros inside any arbitrary scope:
      
      ![Screenshot 2026-02-11 at 2.57.26 PM.png](https://app.graphite.com/user-attachments/assets/1f5a4b80-bd45-4a95-8ac7-881c58d02f60.png)
      
      This is a fantastic feature, but it does mean that our global names are no longer unique.
      
      @mmastrac suggested using `std::any::type_name` with a dummy marker type to get a full path. This PR attempts to do that.
      14c1f8c6
    • JJ Kasper's avatar
      Fix parallel routes with deferred entries (#89967) · ba08f5fe
      JJ Kasper authored
      These were being filtered unexpectedly causing build failures with the
      deferredEntries flag.
      
      x-ref: [slack
      thread](https://vercel.slack.com/archives/C09125LC4AX/p1771010370849309?thread_ts=1770975846.539109&cid=C09125LC4AX)
      ba08f5fe
    • Tobias Koppers's avatar
      Turbopack: Add inline loader configuration via import attributes (#89644) · 740d55cd
      Tobias Koppers authored
      ## What?
      
      Adds support for inline loader configuration in Turbopack via import attributes. Developers can apply webpack-compatible loaders to individual imports using the `with` clause, without needing global `turbopack.rules` configuration.
      
      ```tsx
      import rawText from '../data.txt' with { turbopackLoader: 'raw-loader', turbopackAs: '*.js' }
      import value from '../data.js' with {
        turbopackLoader: 'string-replace-loader',
        turbopackLoaderOptions: '{"search":"PLACEHOLDER","replace":"replaced value"}'
      }
      ```
      
      ## Why?
      
      Global `turbopack.rules` applies loaders to all files matching a pattern. This PR provides per-import granularity — useful when only a specific import needs special treatment, avoiding side effects on other imports of the same file type.
      
      ## How?
      
      ### Import attributes parsing (`turbopack-ecmascript/src/analyzer/imports.rs`)
      - Extended `ImportAnnotations` to parse four new attributes: `turbopackLoader`, `turbopackLoaderOptions`, `turbopackAs`, `turbopackModuleType`
      - All values are strings per TC39 import attributes spec (`turbopackLoaderOptions` is a JSON-encoded string)
      - Added unit tests for the parser
      
      ### New structured loader type (`turbopack-core/src/loader.rs`)
      - Added `WebpackLoaderItem` struct shared between inline and global loader paths
      
      ### Reference type plumbing (`turbopack-core/src/reference_type.rs`, `turbopack-ecmascript/src/references/esm/base.rs`)
      - Added `ImportWithTurbopackUse` variant to `EcmaScriptModulesReferenceSubType` carrying the parsed loader, rename_as, and module_type
      - ESM reference resolution maps the parsed annotations to this new subtype
      
      ### Loader execution (`turbopack/src/lib.rs`)
      - In `process_default_internal`, detects `ImportWithTurbopackUse` references and applies the loader as a source transform via the existing webpack loader infrastructure
      - Requires `enable_webpack_loaders` to be configured (same as global rules)
      - Supports `turbopackAs` (re-processes with new extension) and `turbopackModuleType` (directly sets module type)
      - Avoids infinite recursion by switching to plain `Import` reference type on re-processing
      
      ### Documentation (`docs/.../turbopack.mdx`)
      - Added section documenting the four import attributes with examples
      - Added version history entry for v16.2.0
      
      ### Testing (`test/development/app-dir/turbopack-import-assertions-use/`)
      - E2e test covering raw loader, replace loader with options, `turbopackModuleType: 'ecmascript'`, and `turbopackModuleType: 'json'`
      - Turbopack-only (skipped for webpack)
      740d55cd
    • nextjs-bot's avatar
      v16.2.0-canary.42 · 9abda03e
      nextjs-bot authored
      9abda03e
    • Niklas Mischkulnig's avatar
      Include deployment id query string for preloaded fonts (#89960) · 7784b11e
      Niklas Mischkulnig authored
      This caused two requests and the preloading to not be effective at all
      
      https://github.com/vercel/next.js/pull/89771 added the dpl id in CSS for `url()`s
      7784b11e
    • Luke Sandberg's avatar
      Enable backtraces in turbopack integration tests (#89935) · af4ceab6
      Luke Sandberg authored
      ## Enable Rust backtraces in CI tests
      
      ### What?
      Added `RUST_BACKTRACE=1` environment variable to all Turbopack-related test workflows.
      
      ### Why?
      This change enables detailed Rust backtraces when Turbopack encounters errors during CI tests, making it easier to diagnose and fix issues that occur in the Rust components.
      
      Notably, some assertions/panics are about detecting race conditions, e.g.
      ```
      thread 'tokio-runtime-worker' (1056161) panicked at turbopack/crates/turbo-tasks-backend/src/backend/operation/mod.rs:426:13:
      Concurrent task lock acquisition detected. This is not allowed and indicates a bug. It can lead to deadlocks.
      note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
      ```
      
      Rather than painfully attempting to reproduce locally we can just run with the env var all the time and perhaps that will be enough to figure out rare issues
      af4ceab6
    • Hendrik Liebau's avatar
      Build with dev runtimes when `--debug-prerender` is set (#89834) · e9b96b41
      Hendrik Liebau authored
      When running `next build --debug-prerender`, React owner stacks are now
      captured and displayed in prerender error output. This makes it much
      easier to diagnose which component triggered uncached I/O or accessed
      request data without Suspense. Previously, `--debug-prerender` only
      enabled source maps and disabled minification. Now it also auto-enables
      `allowDevelopmentBuild` and sets `NODE_ENV=development`, which loads
      React development builds where `captureOwnerStack()` is available.
      
      The main challenge is that with `NODE_ENV=development`, both server and
      client bundles include dev-only code paths (HMR, WebSocket connections,
      dev overlay, debug channel, etc.) that expect a running dev server. We
      don't want these when using `next start`. To solve this, we introduce
      `process.env.__NEXT_DEV_SERVER`, an internal env var that is truthy only
      during `next dev`. In client bundles, it's inlined at build time (`'1'`
      for `next dev`, `''` for `next build`). In production server runtime
      bundles, it's inlined as `''` for dead-code elimination. In development
      server runtime bundles, it's left as a runtime check because those
      bundles are shared between `next dev` (where it's set) and `next build
      --debug-prerender` (where it's not). Meanwhile, `NODE_ENV` continues to
      control React's dev/prod mode and error formatting, which is exactly
      what we want for `--debug-prerender`.
      
      This also replaces the previous `renderOpts.dev` / `workStore.dev`
      pattern, which was unreliable because `RouteModule.isDev` was derived
      from `NODE_ENV` at compile time. When `allowDevelopmentBuild` set
      `NODE_ENV=development`, `isDev` would be compiled as `true` and
      incorrectly activate all dev guards during `next start`.
      
      Key changes:
      
      - `config.ts` auto-enables `allowDevelopmentBuild` and sets
      `NODE_ENV=development` when `--debug-prerender` is active
      - `define-env.ts` inlines `__NEXT_DEV_SERVER` into all bundles (truthy
      for dev, falsy for build) so dev-server features are dead-code
      eliminated in production and `--debug-prerender` builds
      - `next-dev.ts` and `next.ts` set `__NEXT_DEV_SERVER` in the process
      environment for externalized server-side code
      - `renderOpts.dev` and `workStore.dev` are removed — all consumers now
      use `__NEXT_DEV_SERVER` (for dev-server features) or `NODE_ENV` (for
      error formatting that should work in both dev and `--debug-prerender`
      builds)
      - `patch-error-inspect.ts` devirtualizes React server URLs in source map
      URLs so they display as readable file paths
      e9b96b41
    • Joseph's avatar
      docs: Activity boundary guide (#89126) · b737b046
      Joseph authored
      b737b046
    • Tobias Koppers's avatar
      Turbopack: Move turbopackIgnoreIssue from experimental to turbopack.ignoreIssue (#89817) · b05a35a7
      Tobias Koppers authored
      ## What?
      
      Moves the `turbopackIgnoreIssue` config from `experimental` to the stable `turbopack` config as `turbopack.ignoreIssue`.
      
      ## Why?
      
      Reviewers on #89682 agreed the API is stable enough to graduate from experimental. Also addresses a docs wording suggestion.
      
      ## How?
      
      - **TypeScript types**: Moved `ignoreIssue` field from `ExperimentalConfig` to `TurbopackOptions` in `config-shared.ts`
      - **Zod schema**: Moved validation from `experimentalSchema` to `zTurbopackConfig` in `config-schema.ts`
      - **Serialization**: Moved RegExp serialization logic into the turbopack block in `build/swc/index.ts`
      - **Rust**: Moved `ignore_issue` field from `ExperimentalConfig` to `TurbopackConfig` in `next_config.rs`, updated the `turbopack_ignore_issue_rules()` method to read from `self.turbopack`
      - **Tests**: Updated config in test to use `turbopack.ignoreIssue` instead of `experimental.turbopackIgnoreIssue`
      - **Docs**: Removed `version: experimental`, updated all code examples, moved entry from experimental table to stable config list in turbopack.mdx, fixed "Good to know" wording to say "prefer using more specific `path` patterns" (since `path` is already required)
      b05a35a7
    • Luke Sandberg's avatar
      fix: support multiple icon formats with same base name (icon.png + icon.svg) (#89504) · fe39a3c4
      Luke Sandberg authored
      ## What?
      
      Fixes a crash in Turbopack and incorrect behavior in Webpack when users have multiple icon files with the same base name but different extensions (e.g., `icon.png` and `icon.svg`) in their app directory.
      
      ## Why?
      
      This is a valid use case for browser fallback support - modern browsers can use SVG icons while older browsers (Safari <26) need to fall back to PNG. Previously:
      
      - **Turbopack**: Crashed during `next build` with "Dependency tracking is disabled so invalidation is not allowed"
      - **Webpack**: Silently ignored all but one format
      
      ## How?
      
      **Turbopack**: Changed virtual source filename from `{stem}--route-entry.js` to `{filename}--route-entry.js` (e.g., `icon.png--route-entry.js` and `icon.svg--route-entry.js`) to avoid file conflicts that triggered invalidation.
      
      **Webpack**: Changed `MetadataResolver` to return all matching files instead of just the first one.
      
      Both icon formats are now properly rendered:
      ```html
      <link rel="icon" type="image/png" sizes="114x114" href="/icon.png">
      <link rel="icon" type="image/svg+xml" sizes="any" href="/icon.svg">
      ```
      
      Fixes #85496
      Fixes NEXT-4816
      fe39a3c4