chore: update rspack 1.6.5

[SyMind]

No description provided.

[ijjk]

Failing test suites

Commit: e138bc7 | About building and testing Next.js

pnpm test-dev test/development/acceptance-app/ReactRefreshLogBoxMisc.test.ts (job)

• ReactRefreshLogBox app > server-side only compilation errors (DD)

Expand output

● ReactRefreshLogBox app › server-side only compilation errors

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/ReactRefreshLogBoxMisc.test.ts:16:5)

pnpm test-dev test/development/acceptance/ReactRefreshLogBox-app-doc.test.ts (job)

• ReactRefreshLogBox _app _document > _app syntax error shows logbox (DD)
• ReactRefreshLogBox _app _document > _document syntax error shows logbox (DD)

Expand output

● ReactRefreshLogBox _app _document › _app syntax error shows logbox

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `ReactRefreshLogBox _app _document _app syntax error shows logbox 1`

- Snapshot  - 6
+ Received  + 5

  {
-   "description": "Parsing ecmascript source code failed",
+   "description": "Could not parse module '[project]/pages/_app.js'
+
+ Expression expected",
    "environmentLabel": null,
-   "label": "Build Error",
-   "source": "./pages/_app.js (2:10)
- Parsing ecmascript source code failed
- > 2 |   return <<Component {...pageProps} />;
-     |          ^^",
+   "label": "Runtime Error",
+   "source": null,
    "stack": [],
  }

  105 |
  106 |     if (isTurbopack) {
> 107 |       await expect(browser).toDisplayRedbox(`
      |                             ^
  108 |        {
  109 |          "description": "Parsing ecmascript source code failed",
  110 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance/ReactRefreshLogBox-app-doc.test.ts:107:29)

● ReactRefreshLogBox _app _document › _document syntax error shows logbox

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `ReactRefreshLogBox _app _document _document syntax error shows logbox 1`

- Snapshot  -  6
+ Received  + 18

  {
-   "description": "Parsing ecmascript source code failed",
-   "environmentLabel": null,
-   "label": "Build Error",
-   "source": "./pages/_document.js (3:36)
+   "description": "./pages/_document.js:3:36
  Parsing ecmascript source code failed
+   1 | import Document, { Html, Head, Main, NextScript } from 'next/document'
+   2 |
  > 3 | class MyDocument extends Document {{
-     |                                    ^",
-   "stack": [],
+     |                                    ^
+   4 |   static async getInitialProps(ctx) {
+   5 |     const initialProps = await Document.getInitialProps(ctx)
+   6 |     return { ...initialProps }
+
+ Unexpected token `{`. Expected identifier, string literal, numeric literal or [ for the computed key
+
+ ",
+   "environmentLabel": null,
+   "label": "Runtime Error",
+   "source": null,
+   "stack": [
+     "<unknown> error: ./pages/_document.js (3:36)",
+     "<unknown> (Error: ./pages/_document.js (3:36)",
+   ],
  }

  224 |     const { browser, session } = sandbox
  225 |     if (isTurbopack) {
> 226 |       await expect(browser).toDisplayRedbox(`
      |                             ^
  227 |        {
  228 |          "description": "Parsing ecmascript source code failed",
  229 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance/ReactRefreshLogBox-app-doc.test.ts:226:29)

pnpm test test/integration/error-plugin-stack-overflow/test/index.test.ts(rspack) (job)

• Reports stack trace when webpack plugin stack overflows > shows details in next build

Expand output

● Reports stack trace when webpack plugin stack overflows › shows details in next build

expect(received).toContain(expected) // indexOf

Expected substring: "caused by plugins in Compilation.hooks.processAssets"
Received string:    "
> Build error occurred
TypeError: Cannot read properties of undefined (reading 'split')

  at formatMessage (../dist/shared/lib/format-webpack-messages.js:56:52)
  at <unknown> (../dist/shared/lib/format-webpack-messages.js:132:16)
      at Array.map (<anonymous>)
  at formatWebpackMessages (../dist/shared/lib/format-webpack-messages.js:130:41)
  at <unknown> (../dist/build/webpack-build/impl.js:275:113)
  at Span.traceFn (../dist/trace/trace.js:150:20)
  at webpackBuildImpl (../dist/build/webpack-build/impl.js:275:66)
  at async (../dist/build/webpack-build/index.js:165:31)
  at async Span.traceAsyncFn (../dist/trace/trace.js:157:20)
  at async (../dist/build/index.js:987:73)
  "
  at Object.toContain (integration/error-plugin-stack-overflow/test/index.test.ts:18:22)

pnpm test-dev-rspack test/development/app-dir/build-error-logs/build-error-logs.test.ts(rspack) (job)

• build-error-logs > should only log error a single time

Expand output

● build-error-logs › should only log error a single time

expect(received).toHaveLength(expected)

Expected length: 2
Received length: 3
Received array:  ["  × Module not found: Can't resolve '@/lib/data' in '/tmp/next-install-97d61ed00bfcf878fb3e01f41b10cf5280a44aa3a29bc75d159cbcb3641d7124/app'", "  × Module not found: Can't resolve '@/lib/data' in '/tmp/next-install-97d61ed00bfcf878fb3e01f41b10cf5280a44aa3a29bc75d159cbcb3641d7124/app'", "  × Module not found: Can't resolve '@/lib/data' in '/tmp/next-install-97d61ed00bfcf878fb3e01f41b10cf5280a44aa3a29bc75d159cbcb3641d7124/app'"]

  20 |       expect(moduleNotFoundLogs).toHaveLength(1)
  21 |     } else if (isRspack) {
> 22 |       expect(moduleNotFoundLogs).toHaveLength(2)
     |                                  ^
  23 |     } else {
  24 |       // FIXME: next with webpack still logs the same error too many times
  25 |       expect(moduleNotFoundLogs).toHaveLength(3)

  at Object.toHaveLength (development/app-dir/build-error-logs/build-error-logs.test.ts:22:34)

pnpm test-dev test/development/acceptance/ReactRefreshLogBox.test.ts (job)

• ReactRefreshLogBox > unterminated JSX (DD)
• ReactRefreshLogBox > css syntax errors (DD)

Expand output

● ReactRefreshLogBox › unterminated JSX

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance/ReactRefreshLogBox.test.ts:429:5)

● ReactRefreshLogBox › css syntax errors

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance/ReactRefreshLogBox.test.ts:693:5)

pnpm test-dev test/e2e/conflicting-app-page-error/index.test.ts (job)

• Conflict between app file and pages file > should show error overlay for /another (DD)
• Conflict between app file and pages file > should show error overlay for / (DD)
• Conflict between app file and pages file > should support hmr with conflicts (DD)
• Conflict between app file and pages file > should not show error overlay for non conflict pages under app or pages dir (DD)
• Conflict between app file and pages file > should error again when there is new conflict (DD)

Expand output

● Conflict between app file and pages file › should show error overlay for /another

Expected Redbox but found no visible one.

  71 |       await next.start()
  72 |       const browser = await next.browser('/another')
> 73 |       await waitForRedbox(browser)
     |       ^
  74 |       await containConflictsError(browser, [
  75 |         ['pages/index.js', 'app/page.js'],
  76 |         ['pages/another.js', 'app/another/page.js'],

  at Object.<anonymous> (e2e/conflicting-app-page-error/index.test.ts:73:7)

● Conflict between app file and pages file › should show error overlay for /

Expected Redbox but found no visible one.

  80 |     it('should show error overlay for /', async () => {
  81 |       const browser = await next.browser('/')
> 82 |       await waitForRedbox(browser)
     |       ^
  83 |       await containConflictsError(browser, [
  84 |         ['pages/index.js', 'app/page.js'],
  85 |         ['pages/another.js', 'app/another/page.js'],

  at Object.<anonymous> (e2e/conflicting-app-page-error/index.test.ts:82:7)

● Conflict between app file and pages file › should support hmr with conflicts

Expected Redbox but found no visible one.

  89 |     it('should support hmr with conflicts', async () => {
  90 |       const browser = await next.browser('/')
> 91 |       await waitForRedbox(browser)
     |       ^
  92 |
  93 |       await next.renameFile('pages/index.js', 'pages/index2.js')
  94 |       await next.renameFile('pages/another.js', 'pages/another2.js')

  at Object.<anonymous> (e2e/conflicting-app-page-error/index.test.ts:91:7)

● Conflict between app file and pages file › should not show error overlay for non conflict pages under app or pages dir

Expected no visible Redbox but found one
header: Runtime Error
Conflicting app and page files were found, please remove the conflicting files to continue:
  "pages/another.js" - "app/another/page.js"
  "pages/index.js" - "app/page.js"

description: Conflicting app and page files were found, please remove the conflicting files to continue:
  "pages/another.js" - "app/another/page.js"
  "pages/index.js" - "app/page.js"

source: null

  110 |
  111 |       await browser.loadPage(next.url + '/non-conflict-pages')
> 112 |       await waitForNoRedbox(browser)
      |       ^
  113 |       expect(await getRedboxHeader(browser)).toEqual(null)
  114 |       expect(await browser.elementByCss('h1').text()).toBe('non-conflict pages')
  115 |     })

  at Object.<anonymous> (e2e/conflicting-app-page-error/index.test.ts:112:7)

● Conflict between app file and pages file › should error again when there is new conflict

ENOENT: no such file or directory, rename '/tmp/next-install-96766ccb1c1973f65c9e1c4822abc8d9adb9de256ba2ce85e68dd40c768fc7d9/pages/index2.js' -> '/tmp/next-install-96766ccb1c1973f65c9e1c4822abc8d9adb9de256ba2ce85e68dd40c768fc7d9/pages/index.js'

pnpm test-dev test/development/acceptance-app/error-recovery.test.ts (job)

• Error recovery app > can recover from a syntax error without losing state (DD)
• Error recovery app > server component can recover from syntax error (DD)
• Error recovery app > client component can recover from syntax error (DD)
• Error recovery app > syntax > runtime error (DD)
• Error recovery app > render error not shown right after syntax error (DD)
• Error recovery app > displays build error on initial page load (DD)

Expand output

● Error recovery app › can recover from a syntax error without losing state

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:41:5)

● Error recovery app › server component can recover from syntax error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:129:5)

● Error recovery app › client component can recover from syntax error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:212:5)

● Error recovery app › syntax > runtime error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:638:5)

● Error recovery app › render error not shown right after syntax error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:893:5)

● Error recovery app › displays build error on initial page load

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `Error recovery app displays build error on initial page load 1`

- Snapshot  -  6
+ Received  + 13

  {
-   "description": "Parsing ecmascript source code failed",
-   "environmentLabel": null,
-   "label": "Build Error",
-   "source": "./app/page.js (1:4)
+   "description": "./app/page.js:1:4
  Parsing ecmascript source code failed
  > 1 | {{{
-     |    ^",
-   "stack": [],
+     |    ^
+
+ Expected '}', got '<eof>'
+
+ ",
+   "environmentLabel": null,
+   "label": "Runtime Error",
+   "source": null,
+   "stack": [
+     "<unknown> error: ./app/page.js (1:4)",
+     "<unknown> (Error: ./app/page.js (1:4)",
+   ],
  }

  1115 |
  1116 |     if (isTurbopack) {
> 1117 |       await expect(browser).toDisplayRedbox(`
       |                             ^
  1118 |        {
  1119 |          "description": "Parsing ecmascript source code failed",
  1120 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance-app/error-recovery.test.ts:1117:29)

pnpm test-dev test/development/acceptance-app/ReactRefreshLogBox.test.ts (job)

• ReactRefreshLogBox app > unterminated JSX (DD)
• ReactRefreshLogBox app > css syntax errors (DD)
• ReactRefreshLogBox app > Import trace when module not found in layout (DD)
• ReactRefreshLogBox app > Can't resolve @import in CSS file (DD)

Expand output

● ReactRefreshLogBox app › unterminated JSX

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/ReactRefreshLogBox.test.ts:268:5)

● ReactRefreshLogBox app › css syntax errors

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/ReactRefreshLogBox.test.ts:479:5)

● ReactRefreshLogBox app › Import trace when module not found in layout

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/ReactRefreshLogBox.test.ts:1401:5)

● ReactRefreshLogBox app › Can't resolve @import in CSS file

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `ReactRefreshLogBox app Can't resolve @import in CSS file 1`

- Snapshot  -  6
+ Received  + 21

  {
-   "description": "Module not found: Can't resolve './boom.css'",
-   "environmentLabel": null,
-   "label": "Build Error",
-   "source": "./app/styles2.css (1:2)
+   "description": "./app/styles2.css:1:2
  Module not found: Can't resolve './boom.css'
  > 1 | @import "./boom.css"
-     |  ^",
-   "stack": [],
+     |  ^
+
+
+
+ Import trace:
+   Client Component Browser:
+     ./app/styles2.css [Client Component Browser]
+     ./app/styles1.css [Client Component Browser]
+     ./app/layout.js [Server Component]
+
+ https://nextjs.org/docs/messages/module-not-found
+
+ ",
+   "environmentLabel": null,
+   "label": "Runtime Error",
+   "source": null,
+   "stack": [
+     "<unknown> error: ./app/styles2.css (1:2)",
+     "<unknown> (Error: ./app/styles2.css (1:2)",
+   ],
  }

  1489 |     // Wait for patch to apply and new error to show.
  1490 |     if (isTurbopack) {
> 1491 |       await expect(browser).toDisplayRedbox(`
       |                             ^
  1492 |        {
  1493 |          "description": "Module not found: Can't resolve './boom.css'",
  1494 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance-app/ReactRefreshLogBox.test.ts:1491:29)

pnpm test-start-rspack test/e2e/app-dir/use-cache-unknown-cache-kind/use-cache-unknown-cache-kind.test.ts(rspack) (job)

• use-cache-unknown-cache-kind > should fail the build with an error

Expand output

● use-cache-unknown-cache-kind › should fail the build with an error

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `use-cache-unknown-cache-kind should fail the build with an error 1`

- Snapshot  - 1
+ Received  + 0

@@ -1,8 +1,7 @@
  "
  ./app/page.tsx
-   × Module build failed:
    ╰─▶   × Error:   x Unknown cache kind "custom". Please configure a cache handler for this kind in the `cacheHandlers` object in your Next.js config.
          │
          │    ,-[1:1]
          │  1 | 'use cache: custom'
          │    : ^^^^^^^^^^^^^^^^^^^

  48 |         `)
  49 |       } else if (isRspack) {
> 50 |         expect(buildOutput).toMatchInlineSnapshot(`
     |                             ^
  51 |          "
  52 |          ./app/page.tsx
  53 |            × Module build failed:

  at Object.toMatchInlineSnapshot (e2e/app-dir/use-cache-unknown-cache-kind/use-cache-unknown-cache-kind.test.ts:50:29)

pnpm test-dev-rspack test/development/app-hmr/hmr.test.ts(rspack) (job)

• app-dir-hmr > filesystem changes > can navigate cleanly to a page that requires a change in the Webpack runtime

Expand output

● app-dir-hmr › filesystem changes › can navigate cleanly to a page that requires a change in the Webpack runtime

page.waitForSelector: Timeout 10000ms exceeded.
Call log:
  - waiting for locator('[data-testid="new-runtime-functionality-page"]')

  519 |
  520 |     return this.startChain(async () => {
> 521 |       const el = await page.waitForSelector(selector, {
      |                             ^
  522 |         timeout,
  523 |         state,
  524 |       })

  at waitForSelector (lib/browsers/playwright.ts:521:29)
  at Object.<anonymous> (development/app-hmr/hmr.test.ts:105:7)
  at Proxy._chain (lib/browsers/playwright.ts:651:23)
  at Proxy._chain (lib/browsers/playwright.ts:632:17)
  at Proxy.startChain (lib/browsers/playwright.ts:520:17)
  at Object.waitForElementByCss (development/app-hmr/hmr.test.ts:108:10)

pnpm test-dev-turbo test/development/app-dir/next-after-app-invalid-usage/index.test.ts (turbopack) (job)

• HMR - Error Recovery, nextConfig: {"basePath":"","assetPrefix":""} > should detect syntax errors and recover (DD)
• HMR - Error Recovery, nextConfig: {"basePath":"","assetPrefix":""} > should recover after webpack parse error in an imported file (DD)
• HMR - Error Recovery, nextConfig: {"basePath":"","assetPrefix":""} > should recover after loader parse error in an imported file (DD)

Expand output

● HMR - Error Recovery, nextConfig: {"basePath":"","assetPrefix":""} › should detect syntax errors and recover

Expected Redbox but found no visible one.

  157 |       (content) => content.replace('</div>', 'div'),
  158 |       async () => {
> 159 |         await waitForRedbox(browser)
      |         ^
  160 |         const source = next.normalizeTestDirContent(
  161 |           await getRedboxSource(browser)
  162 |         )

  at development/basic/hmr/run-error-recovery-hmr-test.util.ts:159:9
  at NextDevInstance.patchFile (lib/next-modes/base.ts:716:9)
  at NextDevInstance.patchFile (lib/next-modes/next-dev.ts:303:16)
  at Object.<anonymous> (development/basic/hmr/run-error-recovery-hmr-test.util.ts:155:5)

● HMR - Error Recovery, nextConfig: {"basePath":"","assetPrefix":""} › should recover after webpack parse error in an imported file

Expected Redbox but found no visible one.

  429 |         ),
  430 |       async () => {
> 431 |         await waitForRedbox(browser)
      |         ^
  432 |         expect(await getRedboxHeader(browser)).toMatch('Build Error')
  433 |
  434 |         if (process.env.IS_TURBOPACK_TEST) {

  at development/basic/hmr/run-error-recovery-hmr-test.util.ts:431:9
  at NextDevInstance.patchFile (lib/next-modes/base.ts:716:9)
  at NextDevInstance.patchFile (lib/next-modes/next-dev.ts:303:16)
  at Object.<anonymous> (development/basic/hmr/run-error-recovery-hmr-test.util.ts:423:5)

● HMR - Error Recovery, nextConfig: {"basePath":"","assetPrefix":""} › should recover after loader parse error in an imported file

Expected Redbox but found no visible one.

  506 |         ),
  507 |       async () => {
> 508 |         await waitForRedbox(browser)
      |         ^
  509 |         expect(await getRedboxHeader(browser)).toMatch('Build Error')
  510 |         let redboxSource = await getRedboxSource(browser)
  511 |

  at development/basic/hmr/run-error-recovery-hmr-test.util.ts:508:9
  at NextDevInstance.patchFile (lib/next-modes/base.ts:716:9)
  at NextDevInstance.patchFile (lib/next-modes/next-dev.ts:303:16)
  at Object.<anonymous> (development/basic/hmr/run-error-recovery-hmr-test.util.ts:500:5)

pnpm test-dev test/development/acceptance/ReactRefreshRegression.test.ts (job)

• ReactRefreshRegression > shows an overlay for a server-side error (DD)

Expand output

● ReactRefreshRegression › shows an overlay for a server-side error

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `ReactRefreshRegression shows an overlay for a server-side error 1`

- Snapshot  - 2
+ Received  + 2

  {
    "description": "boom",
    "environmentLabel": null,
    "label": "Runtime Error",
-   "source": "pages/index.js (1:36) @ __rspack_default_export
+   "source": "pages/index.js (1:36) @ default
  > 1 | export default function () { throw new Error('boom'); }
      |                                    ^",
    "stack": [
-     "__rspack_default_export pages/index.js (1:36)",
+     "default pages/index.js (1:36)",
    ],
  }

  297 |       `)
  298 |     } else {
> 299 |       await expect(browser).toDisplayRedbox(`
      |                             ^
  300 |        {
  301 |          "description": "boom",
  302 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance/ReactRefreshRegression.test.ts:299:29)

pnpm test test/integration/dynamic-optional-routing/test/index.test.ts(rspack) (job)

• Dynamic Optional Routing > production mode > should fail to build when optional route has index.js at root
• Dynamic Optional Routing > production mode > should fail to build when optional route has same page at root
• Dynamic Optional Routing > production mode > should fail to build when mixed with regular catch-all
• Dynamic Optional Routing > production mode > should fail to build when optional but no catch-all

Expand output

● Dynamic Optional Routing › production mode › should fail to build when optional route has index.js at root

TIMED OUT: /You cannot define a route with the same specificity as a optional catch-all route/


> Build error occurred
TypeError: Cannot read properties of undefined (reading 'split')

  at formatMessage (../dist/shared/lib/format-webpack-messages.js:56:52)
  at <unknown> (../dist/shared/lib/format-webpack-messages.js:132:16)
      at Array.map (<anonymous>)
  at formatWebpackMessages (../dist/shared/lib/format-webpack-messages.js:130:41)
  at <unknown> (../dist/build/webpack-build/impl.js:275:113)
  at Span.traceFn (../dist/trace/trace.js:150:20)
  at webpackBuildImpl (../dist/build/webpack-build/impl.js:275:66)
  at async Object.workerMain (../dist/build/webpack-build/impl.js:357:20) {
    type: 'TypeError'
  }
  undefined
  at check (lib/next-test-utils.ts:726:9)
  at Object.<anonymous> (integration/dynamic-optional-routing/test/index.test.ts:190:7)

● Dynamic Optional Routing › production mode › should fail to build when optional route has same page at root

TIMED OUT: /You cannot define a route with the same specificity as a optional catch-all route/


> Build error occurred
TypeError: Cannot read properties of undefined (reading 'split')

  at formatMessage (../dist/shared/lib/format-webpack-messages.js:56:52)
  at <unknown> (../dist/shared/lib/format-webpack-messages.js:132:16)
      at Array.map (<anonymous>)
  at formatWebpackMessages (../dist/shared/lib/format-webpack-messages.js:130:41)
  at <unknown> (../dist/build/webpack-build/impl.js:275:113)
  at Span.traceFn (../dist/trace/trace.js:150:20)
  at webpackBuildImpl (../dist/build/webpack-build/impl.js:275:66)
  at async Object.workerMain (../dist/build/webpack-build/impl.js:357:20) {
    type: 'TypeError'
  }
  undefined
  at check (lib/next-test-utils.ts:726:9)
  at Object.<anonymous> (integration/dynamic-optional-routing/test/index.test.ts:204:7)

● Dynamic Optional Routing › production mode › should fail to build when mixed with regular catch-all

TIMED OUT: /You cannot use both .+ at the same level/


> Build error occurred
TypeError: Cannot read properties of undefined (reading 'split')

  at formatMessage (../dist/shared/lib/format-webpack-messages.js:56:52)
  at <unknown> (../dist/shared/lib/format-webpack-messages.js:132:16)
      at Array.map (<anonymous>)
  at formatWebpackMessages (../dist/shared/lib/format-webpack-messages.js:130:41)
  at <unknown> (../dist/build/webpack-build/impl.js:275:113)
  at Span.traceFn (../dist/trace/trace.js:150:20)
  at webpackBuildImpl (../dist/build/webpack-build/impl.js:275:66)
  at async Object.workerMain (../dist/build/webpack-build/impl.js:357:20) {
    type: 'TypeError'
  }
  undefined
  at check (lib/next-test-utils.ts:726:9)
  at Object.<anonymous> (integration/dynamic-optional-routing/test/index.test.ts:218:7)

● Dynamic Optional Routing › production mode › should fail to build when optional but no catch-all

TIMED OUT: /Optional route parameters are not yet supported/


> Build error occurred
TypeError: Cannot read properties of undefined (reading 'split')

  at formatMessage (../dist/shared/lib/format-webpack-messages.js:56:52)
  at <unknown> (../dist/shared/lib/format-webpack-messages.js:132:16)
      at Array.map (<anonymous>)
  at formatWebpackMessages (../dist/shared/lib/format-webpack-messages.js:130:41)
  at <unknown> (../dist/build/webpack-build/impl.js:275:113)
  at Span.traceFn (../dist/trace/trace.js:150:20)
  at webpackBuildImpl (../dist/build/webpack-build/impl.js:275:66)
  at async Object.workerMain (../dist/build/webpack-build/impl.js:357:20) {
    type: 'TypeError'
  }
  undefined
  at check (lib/next-test-utils.ts:726:9)
  at Object.<anonymous> (integration/dynamic-optional-routing/test/index.test.ts:229:7)

pnpm test-start-rspack test/e2e/on-request-error/server-action-error/server-action-error.test.ts(rspack) (job)

• on-request-error - server-action-error > should catch server action error in listener callback in nodejs runtime
• on-request-error - server-action-error > should catch server action error in listener callback in edge runtime
• on-request-error - server-action-error > should catch the server action form error in nodejs runtime
• on-request-error - server-action-error > should catch the server action form error in edge runtime

Expand output

● on-request-error - server-action-error › should catch server action error in listener callback in nodejs runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "[server-action]:callback"]
Received: []

  28 |         .filter((log) => log.includes('[instrumentation] write-log'))
  29 |
> 30 |       expect(recordLogLines).toEqual(
     |                              ^
  31 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  32 |       )
  33 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/server-action-error/server-action-error.test.ts:30:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/server-action-error/server-action-error.test.ts:25:5)
  at Object.<anonymous> (e2e/on-request-error/server-action-error/server-action-error.test.ts:68:5)

● on-request-error - server-action-error › should catch server action error in listener callback in edge runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "[server-action]:callback:edge"]
Received: []

  28 |         .filter((log) => log.includes('[instrumentation] write-log'))
  29 |
> 30 |       expect(recordLogLines).toEqual(
     |                              ^
  31 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  32 |       )
  33 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/server-action-error/server-action-error.test.ts:30:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/server-action-error/server-action-error.test.ts:25:5)
  at Object.<anonymous> (e2e/on-request-error/server-action-error/server-action-error.test.ts:78:5)

● on-request-error - server-action-error › should catch the server action form error in nodejs runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "[server-action]:form"]
Received: []

  28 |         .filter((log) => log.includes('[instrumentation] write-log'))
  29 |
> 30 |       expect(recordLogLines).toEqual(
     |                              ^
  31 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  32 |       )
  33 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/server-action-error/server-action-error.test.ts:30:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/server-action-error/server-action-error.test.ts:25:5)
  at Object.<anonymous> (e2e/on-request-error/server-action-error/server-action-error.test.ts:88:5)

● on-request-error - server-action-error › should catch the server action form error in edge runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "[server-action]:form:edge"]
Received: []

  28 |         .filter((log) => log.includes('[instrumentation] write-log'))
  29 |
> 30 |       expect(recordLogLines).toEqual(
     |                              ^
  31 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  32 |       )
  33 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/server-action-error/server-action-error.test.ts:30:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/server-action-error/server-action-error.test.ts:25:5)
  at Object.<anonymous> (e2e/on-request-error/server-action-error/server-action-error.test.ts:98:5)

pnpm test test/integration/next-image-new/invalid-image-import/test/index.test.ts (turbopack) (job)

• Missing Import Image Tests > development mode > should show error (DD)

Expand output

● Missing Import Image Tests › development mode › should show error

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `Missing Import Image Tests development mode should show error 1`

- Snapshot  -  0
+ Received  + 16

+ ./test/integration/next-image-new/invalid-image-import/public/invalid.svg
  Processing image failed
+ Failed to parse svg source code for image dimensions
+
+ Caused by:
+ - Source code does not contain a <svg> root element
+
+ Import traces:
+   Browser:
+     ./test/integration/next-image-new/invalid-image-import/public/invalid.svg
+     ./test/integration/next-image-new/invalid-image-import/pages/index.js
+
+   SSR:
+     ./test/integration/next-image-new/invalid-image-import/public/invalid.svg
+     ./test/integration/next-image-new/invalid-image-import/pages/index.js
+
+

  26 |       const description = await getRedboxDescription(browser)
  27 |       if (process.env.IS_TURBOPACK_TEST) {
> 28 |         expect(description).toMatchInlineSnapshot(`"Processing image failed"`)
     |                             ^
  29 |       } else if (process.env.NEXT_RSPACK) {
  30 |         expect(description).toMatchInlineSnapshot(
  31 |           `"  × Error: Image import "../public/invalid.svg" is not a valid image file. The image may be corrupted or an unsupported format."`

  at Object.toMatchInlineSnapshot (integration/next-image-new/invalid-image-import/test/index.test.ts:28:29)

● Missing Import Image Tests › development mode › should show error

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `Missing Import Image Tests development mode should show error 2`

Snapshot: "./test/integration/next-image-new/invalid-image-import/public/invalid.svg
Processing image failed
Failed to parse svg source code for image dimensions

Caused by:
- Source code does not contain a <svg> root element

Import traces:
  Browser:
    ./test/integration/next-image-new/invalid-image-import/public/invalid.svg
    ./test/integration/next-image-new/invalid-image-import/pages/index.js

  SSR:
    ./test/integration/next-image-new/invalid-image-import/public/invalid.svg
    ./test/integration/next-image-new/invalid-image-import/pages/index.js"
Received: null

  38 |       const source = await getRedboxSource(browser)
  39 |       if (process.env.IS_TURBOPACK_TEST) {
> 40 |         expect(source).toMatchInlineSnapshot(`
     |                        ^
  41 |          "./test/integration/next-image-new/invalid-image-import/public/invalid.svg
  42 |          Processing image failed
  43 |          Failed to parse svg source code for image dimensions

  at Object.toMatchInlineSnapshot (integration/next-image-new/invalid-image-import/test/index.test.ts:40:24)

pnpm test-start-rspack test/e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts(rspack) (job)

• on-request-error - dynamic-routes > app router > should catch app router dynamic page error with search params
• on-request-error - dynamic-routes > app router > should catch app router dynamic routes error with search params
• on-request-error - dynamic-routes > app router > should catch suspense rendering page error in node runtime
• on-request-error - dynamic-routes > pages router > should catch pages router dynamic page error with search params
• on-request-error - dynamic-routes > pages router > should catch pages router dynamic API route error with search params

Expand output

● on-request-error - dynamic-routes › app router › should catch app router dynamic page error with search params

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "server-dynamic-page-node-error"]
Received: []

  21 |         .split('\n')
  22 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 23 |       expect(recordLogLines).toEqual(
     |                              ^
  24 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  25 |       )
  26 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:23:30)
  at fn (lib/next-test-utils.ts:797:20)
  at getErrorRecord (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:19:5)
  at Object.<anonymous> (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:42:22)

● on-request-error - dynamic-routes › app router › should catch app router dynamic routes error with search params

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "server-dynamic-route-node-error"]
Received: []

  21 |         .split('\n')
  22 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 23 |       expect(recordLogLines).toEqual(
     |                              ^
  24 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  25 |       )
  26 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:23:30)
  at fn (lib/next-test-utils.ts:797:20)
  at getErrorRecord (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:19:5)
  at Object.<anonymous> (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:62:22)

● on-request-error - dynamic-routes › app router › should catch suspense rendering page error in node runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "server-suspense-page-node-error"]
Received: []

  21 |         .split('\n')
  22 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 23 |       expect(recordLogLines).toEqual(
     |                              ^
  24 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  25 |       )
  26 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:23:30)
  at fn (lib/next-test-utils.ts:797:20)
  at getErrorRecord (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:19:5)
  at Object.<anonymous> (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:82:22)

● on-request-error - dynamic-routes › pages router › should catch pages router dynamic page error with search params

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "pages-page-node-error"]
Received: []

  21 |         .split('\n')
  22 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 23 |       expect(recordLogLines).toEqual(
     |                              ^
  24 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  25 |       )
  26 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:23:30)
  at fn (lib/next-test-utils.ts:797:20)
  at getErrorRecord (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:19:5)
  at Object.<anonymous> (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:105:22)

● on-request-error - dynamic-routes › pages router › should catch pages router dynamic API route error with search params

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "pages-api-node-error"]
Received: []

  21 |         .split('\n')
  22 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 23 |       expect(recordLogLines).toEqual(
     |                              ^
  24 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  25 |       )
  26 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:23:30)
  at fn (lib/next-test-utils.ts:797:20)
  at getErrorRecord (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:19:5)
  at Object.<anonymous> (e2e/on-request-error/dynamic-routes/dynamic-routes.test.ts:126:22)

pnpm test-start-rspack test/e2e/on-request-error/basic/basic.test.ts(rspack) (job)

• on-request-error - basic > app router > should catch server component page error in node runtime
• on-request-error - basic > app router > should catch server component page error in edge runtime
• on-request-error - basic > app router > should catch client component page error in node runtime
• on-request-error - basic > app router > should catch client component page error in edge runtime
• on-request-error - basic > app router > should catch app routes error in node runtime
• on-request-error - basic > app router > should catch app routes error in edge runtime
• on-request-error - basic > middleware > should catch middleware error
• on-request-error - basic > pages router > should catch pages router page error in node runtime
• on-request-error - basic > pages router > should catch pages router page error in edge runtime
• on-request-error - basic > pages router > should catch pages router api error in node runtime
• on-request-error - basic > pages router > should catch pages router api error in edge runtime

Expand output

● on-request-error - basic › app router › should catch server component page error in node runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "server-page-node-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:61:7)

● on-request-error - basic › app router › should catch server component page error in edge runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "server-page-edge-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:70:7)

● on-request-error - basic › app router › should catch client component page error in node runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "client-page-node-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:79:7)

● on-request-error - basic › app router › should catch client component page error in edge runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "client-page-edge-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:89:7)

● on-request-error - basic › app router › should catch app routes error in node runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "route-node-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:99:7)

● on-request-error - basic › app router › should catch app routes error in edge runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "route-edge-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:108:7)

● on-request-error - basic › pages router › should catch pages router page error in node runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "pages-page-node-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:119:7)

● on-request-error - basic › pages router › should catch pages router page error in edge runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "pages-page-edge-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:128:7)

● on-request-error - basic › pages router › should catch pages router api error in node runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "api-node-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:137:7)

● on-request-error - basic › pages router › should catch pages router api error in edge runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "api-edge-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:146:7)

● on-request-error - basic › middleware › should catch middleware error

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "middleware-error"]
Received: []

  29 |         .split('\n')
  30 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 31 |       expect(recordLogLines).toEqual(
     |                              ^
  32 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  33 |       )
  34 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/basic/basic.test.ts:31:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/basic/basic.test.ts:27:5)
  at Object.<anonymous> (e2e/on-request-error/basic/basic.test.ts:157:7)

pnpm test-dev-turbo test/e2e/app-dir/cache-components-route-handler-errors/cache-components-route-handler-errors.test.ts (turbopack) (job)

• pages/ error recovery > logbox: can recover from a syntax error without losing state (DD)
• pages/ error recovery > render error not shown right after syntax error (DD)
• pages/ error recovery > syntax > runtime error (DD)

Expand output

● pages/ error recovery › logbox: can recover from a syntax error without losing state

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance/error-recovery.test.ts:43:5)

● pages/ error recovery › render error not shown right after syntax error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance/error-recovery.test.ts:374:5)

● pages/ error recovery › syntax > runtime error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance/error-recovery.test.ts:791:5)

pnpm test-dev-turbo test/development/sass-error/index.test.ts (turbopack) (job)

• app-dir action handling > "use server" export values > should error when exporting non async functions at build time (DD)

Expand output

● app-dir action handling › "use server" export values › should error when exporting non async functions at build time

Expected Redbox but found no visible one.

   996 |           )
   997 |
>  998 |           await waitForRedbox(browser)
       |           ^
   999 |           expect(await getRedboxSource(browser)).toContain(
  1000 |             'Only async functions are allowed to be exported in a "use server" file.'
  1001 |           )

  at Object.<anonymous> (e2e/app-dir/actions/app-action.test.ts:998:11)

pnpm test-dev test/development/pages-dir/client-navigation/rendering.test.ts (job)

• ReactRefreshLogBox app > Should not show webpack_exports when exporting anonymous arrow function (DD)

Expand output

● ReactRefreshLogBox app › Should not show webpack_exports when exporting anonymous arrow function

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `ReactRefreshLogBox app Should not show __webpack_exports__ when exporting anonymous arrow function 1`

- Snapshot  - 2
+ Received  + 2

  {
    "description": "test",
    "environmentLabel": null,
    "label": "Runtime Error",
-   "source": "index.js (3:11) @ __rspack_default_export
+   "source": "index.js (3:11) @ default
  > 3 |     throw new Error('test')
      |           ^",
    "stack": [
-     "__rspack_default_export index.js (3:11)",
+     "default index.js (3:11)",
      "Page app/page.js (4:10)",
    ],
  }

  1055 |       `)
  1056 |     } else {
> 1057 |       await expect(browser).toDisplayRedbox(`
       |                             ^
  1058 |        {
  1059 |          "description": "test",
  1060 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance-app/ReactRefreshLogBox.test.ts:1057:29)

pnpm test-dev-turbo test/development/acceptance-app/editor-links.test.ts (turbopack) (job)

• app-dir action handling > "use server" export values > should error when exporting non async functions at build time (DD)

Expand output

● app-dir action handling › "use server" export values › should error when exporting non async functions at build time

Expected Redbox but found no visible one.

   996 |           )
   997 |
>  998 |           await waitForRedbox(browser)
       |           ^
   999 |           expect(await getRedboxSource(browser)).toContain(
  1000 |             'Only async functions are allowed to be exported in a "use server" file.'
  1001 |           )

  at Object.<anonymous> (e2e/app-dir/actions/app-action.test.ts:998:11)

pnpm test-start-rspack test/e2e/on-request-error/otel/otel.test.ts(rspack) (job)

• on-request-error - otel > app router > should catch server component page error in node runtime
• on-request-error - otel > app router > should catch app routes error in node runtime

Expand output

● on-request-error - otel › app router › should catch server component page error in node runtime

expect(received).toEqual(expected) // deep equality

Expected: ArrayContaining [StringContaining "server-page-node-error"]
Received: []

  34 |         .split('\n')
  35 |         .filter((log) => log.includes('[instrumentation] write-log'))
> 36 |       expect(recordLogLines).toEqual(
     |                              ^
  37 |         expect.arrayContaining([expect.stringContaining(errorMessage)])
  38 |       )
  39 |       // TODO: remove custom duration in case we increase the default.

  at toEqual (e2e/on-request-error/otel/otel.test.ts:36:30)
  at fn (lib/next-test-utils.ts:797:20)
  at validateErrorRecord (e2e/on-request-error/otel/otel.test.ts:32:5)
  at Object.<anonymous> (e2e/on-request-error/otel/otel.test.ts:66:7)

● on-request-error - otel › app router › should catch app routes error in node runtime

thrown: "Exceeded timeout of 120000 ms for a test.
Add a timeout value to this test to increase the timeout, if this is a long-running test. See https://jestjs.io/docs/api#testname-fn-timeout."

  71 |     })
  72 |
> 73 |     it('should catch app routes error in node runtime', async () => {
     |     ^
  74 |       await next.fetch('/app-route')
  75 |
  76 |       await validateErrorRecord({

  at it (e2e/on-request-error/otel/otel.test.ts:73:5)
  at describe (e2e/on-request-error/otel/otel.test.ts:63:3)
  at Object.describe (e2e/on-request-error/otel/otel.test.ts:5:1)

pnpm test-dev-turbo test/development/basic/hmr/basic-no-base-path-yes-asset-prefix.test.ts (turbopack) (job)

• Error recovery app > can recover from a syntax error without losing state (DD)
• Error recovery app > server component can recover from syntax error (DD)
• Error recovery app > client component can recover from syntax error (DD)
• Error recovery app > syntax > runtime error (DD)
• Error recovery app > stuck error (DD)
• Error recovery app > render error not shown right after syntax error (DD)
• Error recovery app > displays build error on initial page load (DD)

Expand output

● Error recovery app › can recover from a syntax error without losing state

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:41:5)

● Error recovery app › server component can recover from syntax error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:129:5)

● Error recovery app › client component can recover from syntax error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:212:5)

● Error recovery app › syntax > runtime error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:638:5)

● Error recovery app › stuck error

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `Error recovery app stuck error 1`

- Snapshot  - 13
+ Received  +  1

- {
-   "description": "React is not defined",
-   "environmentLabel": null,
-   "label": "Runtime ReferenceError",
-   "source": "Foo.js (3:3) @ Foo
- > 3 |   return React.createElement('h1', null, 'Foo');
-     |   ^",
-   "stack": [
-     "Foo Foo.js (3:3)",
-     "FunctionDefault index.js (4:10)",
-     "<FIXME-file-protocol>",
-   ],
- }
+ "Expected Redbox but found no visible one."

  818 |     if (isTurbopack) {
  819 |       // TODO(veil): Possibly https://linear.app/vercel/issue/NDX-920/
> 820 |       await expect(browser).toDisplayRedbox(`
      |                             ^
  821 |        {
  822 |          "description": "React is not defined",
  823 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance-app/error-recovery.test.ts:820:29)

● Error recovery app › render error not shown right after syntax error

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/error-recovery.test.ts:893:5)

● Error recovery app › displays build error on initial page load

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `Error recovery app displays build error on initial page load 1`

- Snapshot  -  6
+ Received  + 13

  {
-   "description": "Parsing ecmascript source code failed",
-   "environmentLabel": null,
-   "label": "Build Error",
-   "source": "./app/page.js (1:4)
+   "description": "./app/page.js:1:4
  Parsing ecmascript source code failed
  > 1 | {{{
-     |    ^",
-   "stack": [],
+     |    ^
+
+ Expected '}', got '<eof>'
+
+ ",
+   "environmentLabel": null,
+   "label": "Runtime Error",
+   "source": null,
+   "stack": [
+     "<unknown> error: ./app/page.js (1:4)",
+     "<unknown> (Error: ./app/page.js (1:4)",
+   ],
  }

  1115 |
  1116 |     if (isTurbopack) {
> 1117 |       await expect(browser).toDisplayRedbox(`
       |                             ^
  1118 |        {
  1119 |          "description": "Parsing ecmascript source code failed",
  1120 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance-app/error-recovery.test.ts:1117:29)

pnpm test-dev-turbo test/development/acceptance-app/error-message-url.test.ts (turbopack) (job)

• ReactRefreshLogBox app > unterminated JSX (DD)
• ReactRefreshLogBox app > css syntax errors (DD)
• ReactRefreshLogBox app > Import trace when module not found in layout (DD)
• ReactRefreshLogBox app > Can't resolve @import in CSS file (DD)

Expand output

● ReactRefreshLogBox app › unterminated JSX

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/ReactRefreshLogBox.test.ts:268:5)

● ReactRefreshLogBox app › css syntax errors

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/ReactRefreshLogBox.test.ts:479:5)

● ReactRefreshLogBox app › Import trace when module not found in layout

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/ReactRefreshLogBox.test.ts:1401:5)

● ReactRefreshLogBox app › Can't resolve @import in CSS file

expect(received).toMatchInlineSnapshot(snapshot)

Snapshot name: `ReactRefreshLogBox app Can't resolve @import in CSS file 1`

- Snapshot  -  6
+ Received  + 21

  {
-   "description": "Module not found: Can't resolve './boom.css'",
-   "environmentLabel": null,
-   "label": "Build Error",
-   "source": "./app/styles2.css (1:2)
+   "description": "./app/styles2.css:1:2
  Module not found: Can't resolve './boom.css'
  > 1 | @import "./boom.css"
-     |  ^",
-   "stack": [],
+     |  ^
+
+
+
+ Import trace:
+   Client Component Browser:
+     ./app/styles2.css [Client Component Browser]
+     ./app/styles1.css [Client Component Browser]
+     ./app/layout.js [Server Component]
+
+ https://nextjs.org/docs/messages/module-not-found
+
+ ",
+   "environmentLabel": null,
+   "label": "Runtime Error",
+   "source": null,
+   "stack": [
+     "<unknown> error: ./app/styles2.css (1:2)",
+     "<unknown> (Error: ./app/styles2.css (1:2)",
+   ],
  }

  1489 |     // Wait for patch to apply and new error to show.
  1490 |     if (isTurbopack) {
> 1491 |       await expect(browser).toDisplayRedbox(`
       |                             ^
  1492 |        {
  1493 |          "description": "Module not found: Can't resolve './boom.css'",
  1494 |          "environmentLabel": null,

  at Object.toDisplayRedbox (development/acceptance-app/ReactRefreshLogBox.test.ts:1491:29)

pnpm test-dev-turbo test/development/app-dir/server-component-next-dynamic-ssr-false/server-component-next-dynamic-ssr-false.test.ts (turbopack) (job)

• Error overlay - RSC build errors > should throw an error when getServerSideProps is used (DD)
• Error overlay - RSC build errors > should throw an error when metadata export is used in client components (DD)
• Error overlay - RSC build errors > should throw an error when metadata exports are used together in server components (DD)
• Error overlay - RSC build errors > should throw an error when "use client" is on the top level but after other expressions (DD)
• Error overlay - RSC build errors > should throw an error when "Component" is imported in server components (DD)
• Error overlay - RSC build errors > should allow to use and handle rsc poisoning client-only (DD)
• Error overlay - RSC build errors > should error when Component from react is used in server component (DD)
• Error overlay - RSC build errors > should error when createContext from react is used in server component (DD)
• Error overlay - RSC build errors > should error when createFactory from react is used in server component (DD)
• Error overlay - RSC build errors > should error when PureComponent from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useDeferredValue from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useEffect from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useImperativeHandle from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useInsertionEffect from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useLayoutEffect from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useReducer from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useRef from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useState from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useSyncExternalStore from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useTransition from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useOptimistic from react is used in server component (DD)
• Error overlay - RSC build errors > should error when useActionState from react is used in server component (DD)
• Error overlay - RSC build errors > should error when flushSync from react-dom is used in server component (DD)
• Error overlay - RSC build errors > should error when unstable_batchedUpdates from react-dom is used in server component (DD)
• Error overlay - RSC build errors > should error when useFormStatus from react-dom is used in server component (DD)
• Error overlay - RSC build errors > should error when useFormState from react-dom is used in server component (DD)
• Error overlay - RSC build errors > should allow to use and handle rsc poisoning server-only (DD)
• Error overlay - RSC build errors > should throw an error when error file is a server component (DD)
• Error overlay - RSC build errors > should throw an error when error file is a server component with empty error file (DD)
• Error overlay - RSC build errors > importing 'next/cache' APIs in a client component > revalidatePath is not allowed (DD)
• Error overlay - RSC build errors > importing 'next/cache' APIs in a client component > revalidateTag is not allowed (DD)
• Error overlay - RSC build errors > importing 'next/cache' APIs in a client component > cacheLife is not allowed (DD)
• Error overlay - RSC build errors > importing 'next/cache' APIs in a client component > cacheTag is not allowed (DD)
• Error overlay - RSC build errors > next/root-params > importing 'next/root-params' when experimental.rootParams is not enabled (DD)
• Error overlay - RSC build errors > next/root-params > importing 'next/root-params' in a client component (DD)
• Error overlay - RSC build errors > next/root-params > importing 'next/root-params' in a client component in a way that bypasses import analysis (DD)

Expand output

● Error overlay - RSC build errors › should throw an error when getServerSideProps is used

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:25:5)

● Error overlay - RSC build errors › should throw an error when metadata export is used in client components

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:48:5)

● Error overlay - RSC build errors › should throw an error when metadata exports are used together in server components

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:88:5)

● Error overlay - RSC build errors › should throw an error when "use client" is on the top level but after other expressions

Expected Redbox but found no visible one.

  128 |     await next.patchFile(pageFile, uncomment)
  129 |
> 130 |     await session.waitForRedbox()
      |     ^
  131 |     expect(await session.getRedboxSource()).toInclude(
  132 |       'directive must be placed before other expressions'
  133 |     )

  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:130:5)

● Error overlay - RSC build errors › should throw an error when "Component" is imported in server components

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:149:5)

● Error overlay - RSC build errors › should allow to use and handle rsc poisoning client-only

Expected Redbox but found no visible one.

  171 |     await next.patchFile(file, uncomment)
  172 |
> 173 |     await session.waitForRedbox()
      |     ^
  174 |     if (isTurbopack) {
  175 |       // TODO: fix the issue ordering.
  176 |       // turbopack emits the resolve issue first instead of the transform issue.

  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:173:5)

● Error overlay - RSC build errors › should error when Component from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when createContext from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when createFactory from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when PureComponent from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useDeferredValue from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useEffect from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useImperativeHandle from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useInsertionEffect from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useLayoutEffect from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useReducer from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useRef from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useState from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useSyncExternalStore from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useTransition from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useOptimistic from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when useActionState from react is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  226 |       const { session } = sandbox
  227 |       await session.waitForRedbox()
> 228 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  229 |         // `Component` has a custom error message
  230 |         api === 'Component'
  231 |           ? `You’re importing a class component. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:228:47)

● Error overlay - RSC build errors › should error when flushSync from react-dom is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  250 |       const { session } = sandbox
  251 |       await session.waitForRedbox()
> 252 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  253 |         `You're importing a component that needs \`${api}\`. This React Hook only works in a Client Component. To fix, mark the file (or its parent) with the \`"use client"\` directive.`
  254 |       )
  255 |     })

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:252:47)

● Error overlay - RSC build errors › should error when unstable_batchedUpdates from react-dom is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  250 |       const { session } = sandbox
  251 |       await session.waitForRedbox()
> 252 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  253 |         `You're importing a component that needs \`${api}\`. This React Hook only works in a Client Component. To fix, mark the file (or its parent) with the \`"use client"\` directive.`
  254 |       )
  255 |     })

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:252:47)

● Error overlay - RSC build errors › should error when useFormStatus from react-dom is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  250 |       const { session } = sandbox
  251 |       await session.waitForRedbox()
> 252 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  253 |         `You're importing a component that needs \`${api}\`. This React Hook only works in a Client Component. To fix, mark the file (or its parent) with the \`"use client"\` directive.`
  254 |       )
  255 |     })

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:252:47)

● Error overlay - RSC build errors › should error when useFormState from react-dom is used in server component

TypeError: Cannot read properties of null (reading 'includes')

  250 |       const { session } = sandbox
  251 |       await session.waitForRedbox()
> 252 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  253 |         `You're importing a component that needs \`${api}\`. This React Hook only works in a Client Component. To fix, mark the file (or its parent) with the \`"use client"\` directive.`
  254 |       )
  255 |     })

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:252:47)

● Error overlay - RSC build errors › should allow to use and handle rsc poisoning server-only

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:273:5)

● Error overlay - RSC build errors › importing 'next/cache' APIs in a client component › revalidatePath is not allowed

TypeError: Cannot read properties of null (reading 'includes')

  290 |         const { session } = sandbox
  291 |         await session.waitForRedbox()
> 292 |         expect(await session.getRedboxSource()).toInclude(
      |                                                 ^
  293 |           `You're importing a component that needs "${api}". That only works in a Server Component but one of its parents is marked with "use client", so it's a Client Component.`
  294 |         )
  295 |       }

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at toInclude (development/acceptance-app/rsc-build-errors.test.ts:292:49)

● Error overlay - RSC build errors › importing 'next/cache' APIs in a client component › revalidateTag is not allowed

TypeError: Cannot read properties of null (reading 'includes')

  290 |         const { session } = sandbox
  291 |         await session.waitForRedbox()
> 292 |         expect(await session.getRedboxSource()).toInclude(
      |                                                 ^
  293 |           `You're importing a component that needs "${api}". That only works in a Server Component but one of its parents is marked with "use client", so it's a Client Component.`
  294 |         )
  295 |       }

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at toInclude (development/acceptance-app/rsc-build-errors.test.ts:292:49)

● Error overlay - RSC build errors › importing 'next/cache' APIs in a client component › cacheLife is not allowed

TypeError: Cannot read properties of null (reading 'includes')

  290 |         const { session } = sandbox
  291 |         await session.waitForRedbox()
> 292 |         expect(await session.getRedboxSource()).toInclude(
      |                                                 ^
  293 |           `You're importing a component that needs "${api}". That only works in a Server Component but one of its parents is marked with "use client", so it's a Client Component.`
  294 |         )
  295 |       }

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at toInclude (development/acceptance-app/rsc-build-errors.test.ts:292:49)

● Error overlay - RSC build errors › importing 'next/cache' APIs in a client component › cacheTag is not allowed

TypeError: Cannot read properties of null (reading 'includes')

  290 |         const { session } = sandbox
  291 |         await session.waitForRedbox()
> 292 |         expect(await session.getRedboxSource()).toInclude(
      |                                                 ^
  293 |           `You're importing a component that needs "${api}". That only works in a Server Component but one of its parents is marked with "use client", so it's a Client Component.`
  294 |         )
  295 |       }

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at toInclude (development/acceptance-app/rsc-build-errors.test.ts:292:49)

● Error overlay - RSC build errors › next/root-params › importing 'next/root-params' when experimental.rootParams is not enabled

TypeError: Cannot read properties of null (reading 'includes')

  322 |       await session.waitForRedbox()
  323 |       if (!isCacheComponentsEnabled) {
> 324 |         expect(await session.getRedboxSource()).toInclude(
      |                                                 ^
  325 |           `'next/root-params' can only be imported when \`experimental.rootParams\` is enabled.`
  326 |         )
  327 |       } else {

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:324:49)

● Error overlay - RSC build errors › next/root-params › importing 'next/root-params' in a client component

TypeError: Cannot read properties of null (reading 'includes')

  353 |       const { session } = sandbox
  354 |       await session.waitForRedbox()
> 355 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  356 |         `You're importing a component that needs "next/root-params". That only works in a Server Component but one of its parents is marked with "use client", so it's a Client Component.`
  357 |       )
  358 |     })

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:355:47)

● Error overlay - RSC build errors › next/root-params › importing 'next/root-params' in a client component in a way that bypasses import analysis

TypeError: Cannot read properties of null (reading 'includes')

  376 |       const { session } = sandbox
  377 |       await session.waitForRedbox()
> 378 |       expect(await session.getRedboxSource()).toInclude(
      |                                               ^
  379 |         `'next/root-params' cannot be imported from a Client Component module. It should only be used from a Server Component.`
  380 |       )
  381 |     })

  at Object.toInclude (../node_modules/.pnpm/jest-extended@4.0.2_jest@29.7.0_@types+node@20.17.6_patch_hash=rvl3vkomen3tospgr67bzubfyu__babel-plugin-macros@3.1.0_/node_modules/jest-extended/dist/matchers/toInclude.js:13:23)
  at __EXTERNAL_MATCHER_TRAP__ (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:325:30)
  at Object.throwingMatcher [as toInclude] (../node_modules/.pnpm/expect@29.7.0/node_modules/expect/build/index.js:326:15)
  at Object.toInclude (development/acceptance-app/rsc-build-errors.test.ts:378:47)

● Error overlay - RSC build errors › should throw an error when error file is a server component

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:412:5)

● Error overlay - RSC build errors › should throw an error when error file is a server component with empty error file

Application is in inconsistent state: timeout.

  113 |             }
  114 |             if (status !== 'pending') {
> 115 |               throw new Error(
      |                     ^
  116 |                 `Application is in inconsistent state: ${status}.`
  117 |               )
  118 |             }

  at Object.patch (lib/development-sandbox.ts:115:21)
  at Object.<anonymous> (development/acceptance-app/rsc-build-errors.test.ts:465:5)

[ijjk]

Stats from current PR

Default Build (Increase detected ⚠️)

General

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
buildDuration	17.2s	15s	N/A
buildDurationCached	13.8s	10.8s	N/A
nodeModulesSize	456 MB	456 MB	N/A
nextStartRea..uration (ms)	714ms	711ms	N/A

Client Bundles (main, webpack) Overall increase ⚠️

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
4951-HASH.js gzip	5.37 kB	5.38 kB	N/A
68680909-HASH.js gzip	62.3 kB	62.3 kB	N/A
8034-HASH.js gzip	52.8 kB	53 kB	⚠️ +204 B
9564.HASH.js gzip	170 B	168 B	N/A
9565-HASH.js gzip	4.46 kB	4.48 kB	N/A
framework-HASH.js gzip	59.7 kB	59.7 kB	N/A
main-app-HASH.js gzip	255 B	252 B	N/A
main-HASH.js gzip	38.6 kB	38.5 kB	N/A
webpack-HASH.js gzip	1.69 kB	1.69 kB	N/A
Overall change	52.8 kB	53 kB	⚠️ +204 B

Legacy Client Bundles (polyfills)

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
polyfills-HASH.js gzip	39.4 kB	39.4 kB	✓
Overall change	39.4 kB	39.4 kB	✓

Client Pages

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
_app-HASH.js gzip	192 B	194 B	N/A
_error-HASH.js gzip	183 B	182 B	N/A
css-HASH.js gzip	334 B	333 B	N/A
dynamic-HASH.js gzip	1.79 kB	1.81 kB	N/A
edge-ssr-HASH.js gzip	254 B	255 B	N/A
head-HASH.js gzip	352 B	349 B	N/A
hooks-HASH.js gzip	383 B	378 B	N/A
image-HASH.js gzip	580 B	581 B	N/A
index-HASH.js gzip	259 B	258 B	N/A
link-HASH.js gzip	2.51 kB	2.5 kB	N/A
routerDirect..HASH.js gzip	317 B	319 B	N/A
script-HASH.js gzip	386 B	386 B	✓
withRouter-HASH.js gzip	314 B	312 B	N/A
1afbb74e6ecf..834.css gzip	106 B	106 B	✓
Overall change	492 B	492 B	✓

Client Build Manifests

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
_buildManifest.js gzip	735 B	738 B	N/A
Overall change	0 B	0 B	✓

Rendered Page Sizes

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
index.html gzip	524 B	523 B	N/A
link.html gzip	539 B	539 B	✓
withRouter.html gzip	521 B	520 B	N/A
Overall change	539 B	539 B	✓

Edge SSR bundle Size

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
edge-ssr.js gzip	126 kB	126 kB	N/A
page.js gzip	236 kB	236 kB	N/A
Overall change	0 B	0 B	✓

Middleware size

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
middleware-b..fest.js gzip	652 B	653 B	N/A
middleware-r..fest.js gzip	156 B	156 B	✓
middleware.js gzip	32.8 kB	32.9 kB	N/A
edge-runtime..pack.js gzip	846 B	846 B	✓
Overall change	1 kB	1 kB	✓

Next Runtimes

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
app-page-exp...dev.js gzip	301 kB	300 kB	N/A
app-page-exp..prod.js gzip	155 kB	155 kB	✓
app-page-tur...dev.js gzip	300 kB	300 kB	N/A
app-page-tur..prod.js gzip	155 kB	155 kB	✓
app-page-tur...dev.js gzip	297 kB	297 kB	N/A
app-page-tur..prod.js gzip	153 kB	153 kB	✓
app-page.run...dev.js gzip	297 kB	297 kB	N/A
app-page.run..prod.js gzip	153 kB	153 kB	✓
app-route-ex...dev.js gzip	68.5 kB	68.5 kB	N/A
app-route-ex..prod.js gzip	47.3 kB	47.3 kB	✓
app-route-tu...dev.js gzip	68.5 kB	68.5 kB	N/A
app-route-tu..prod.js gzip	47.3 kB	47.3 kB	✓
app-route-tu...dev.js gzip	68.1 kB	68.1 kB	N/A
app-route-tu..prod.js gzip	47.1 kB	47.1 kB	✓
app-route.ru...dev.js gzip	68.1 kB	68 kB	N/A
app-route.ru..prod.js gzip	47.1 kB	47.1 kB	✓
dist_client_...dev.js gzip	326 B	326 B	✓
dist_client_...dev.js gzip	328 B	328 B	✓
dist_client_...dev.js gzip	320 B	320 B	✓
dist_client_...dev.js gzip	318 B	318 B	✓
pages-api-tu...dev.js gzip	40.9 kB	40.8 kB	N/A
pages-api-tu..prod.js gzip	31 kB	31 kB	✓
pages-api.ru...dev.js gzip	40.8 kB	40.8 kB	N/A
pages-api.ru..prod.js gzip	30.9 kB	30.9 kB	✓
pages-turbo....dev.js gzip	50.3 kB	50.3 kB	N/A
pages-turbo...prod.js gzip	37.8 kB	37.8 kB	✓
pages.runtim...dev.js gzip	50.3 kB	50.3 kB	N/A
pages.runtim..prod.js gzip	37.8 kB	37.8 kB	✓
server.runti..prod.js gzip	59.8 kB	59.8 kB	✓
Overall change	1 MB	1 MB	✓

build cache

	vercel/next.js canary	SyMind/next.js update-rspack-1.6.5	Change
0.pack gzip	3.1 MB	3.1 MB	N/A
index.pack gzip	93.8 kB	93.5 kB	N/A
Overall change	0 B	0 B	✓

Diff details

Diff for page.js

Diff too large to display

Diff for middleware.js

Diff too large to display

Diff for edge-ssr.js

Diff too large to display

Diff for _buildManifest.js

@@ -611,35 +611,35 @@ self.__BUILD_MANIFEST = (function (a, b, c) {
       numHashes: NaN,
       bitArray: [],
     },
-    "/": ["static\u002Fchunks\u002Fpages\u002Findex-b087a17851e05d6f.js"],
+    "/": ["static\u002Fchunks\u002Fpages\u002Findex-3361ed053e34d664.js"],
     "/_error": [
-      "static\u002Fchunks\u002Fpages\u002F_error-0d6cadd1684bf608.js",
+      "static\u002Fchunks\u002Fpages\u002F_error-c7ffde23a6d1e061.js",
     ],
     "/css": [
       "static\u002Fcss\u002Fded6b86ab9cc0a1f.css",
-      "static\u002Fchunks\u002Fpages\u002Fcss-d018beb4ee617700.js",
+      "static\u002Fchunks\u002Fpages\u002Fcss-0b6177a056485c89.js",
     ],
     "/dynamic": [
-      "static\u002Fchunks\u002Fpages\u002Fdynamic-22fa1f98925287e3.js",
+      "static\u002Fchunks\u002Fpages\u002Fdynamic-8e7954693aad6744.js",
     ],
     "/edge-ssr": [
-      "static\u002Fchunks\u002Fpages\u002Fedge-ssr-79392016bf448b0e.js",
+      "static\u002Fchunks\u002Fpages\u002Fedge-ssr-7515805a0793fb50.js",
     ],
-    "/head": ["static\u002Fchunks\u002Fpages\u002Fhead-7c5bbe7e16e0461c.js"],
-    "/hooks": ["static\u002Fchunks\u002Fpages\u002Fhooks-9fbae4ac20575871.js"],
+    "/head": ["static\u002Fchunks\u002Fpages\u002Fhead-18530459356f6f47.js"],
+    "/hooks": ["static\u002Fchunks\u002Fpages\u002Fhooks-221843a8082c5fe0.js"],
     "/image": [
-      "static\u002Fchunks\u002F9565-2e0c4004742fb14a.js",
-      "static\u002Fchunks\u002Fpages\u002Fimage-811425894781cf7d.js",
+      "static\u002Fchunks\u002F5467-5440e689c12d4e40.js",
+      "static\u002Fchunks\u002Fpages\u002Fimage-fe20cdcfe67a7d4d.js",
     ],
-    "/link": ["static\u002Fchunks\u002Fpages\u002Flink-14068c948da9dc39.js"],
+    "/link": ["static\u002Fchunks\u002Fpages\u002Flink-814c1a2b0c6775c5.js"],
     "/routerDirect": [
-      "static\u002Fchunks\u002Fpages\u002FrouterDirect-6d3e9dcd1348423d.js",
+      "static\u002Fchunks\u002Fpages\u002FrouterDirect-a0028e2a28aa8c85.js",
     ],
     "/script": [
-      "static\u002Fchunks\u002Fpages\u002Fscript-eda35f71f7a910ba.js",
+      "static\u002Fchunks\u002Fpages\u002Fscript-5b734e02315dd67a.js",
     ],
     "/withRouter": [
-      "static\u002Fchunks\u002Fpages\u002FwithRouter-4a6d5ec263e28451.js",
+      "static\u002Fchunks\u002Fpages\u002FwithRouter-db2aefa859481ae2.js",
     ],
     sortedPages: [
       "\u002F",

Diff for css-HASH.js

@@ -1,14 +1,7 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [9813],
   {
-    /***/ 1361: /***/ (module) => {
-      // extracted by mini-css-extract-plugin
-      module.exports = { helloWorld: "css_helloWorld__aUdUq" };
-
-      /***/
-    },
-
-    /***/ 1651: /***/ (
+    /***/ 942: /***/ (
       __unused_webpack_module,
       __unused_webpack_exports,
       __webpack_require__
@@ -16,7 +9,7 @@
       (window.__NEXT_P = window.__NEXT_P || []).push([
         "/css",
         function () {
-          return __webpack_require__(3321);
+          return __webpack_require__(3023);
         },
       ]);
       if (false) {
@@ -25,7 +18,7 @@
       /***/
     },
 
-    /***/ 3321: /***/ (
+    /***/ 3023: /***/ (
       __unused_webpack_module,
       __webpack_exports__,
       __webpack_require__
@@ -39,7 +32,7 @@
       /* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ =
         __webpack_require__(7002);
       /* harmony import */ var _css_module_css__WEBPACK_IMPORTED_MODULE_1__ =
-        __webpack_require__(1361);
+        __webpack_require__(3264);
       /* harmony import */ var _css_module_css__WEBPACK_IMPORTED_MODULE_1___default =
         /*#__PURE__*/ __webpack_require__.n(
           _css_module_css__WEBPACK_IMPORTED_MODULE_1__
@@ -58,13 +51,20 @@
 
       /***/
     },
+
+    /***/ 3264: /***/ (module) => {
+      // extracted by mini-css-extract-plugin
+      module.exports = { helloWorld: "css_helloWorld__aUdUq" };
+
+      /***/
+    },
   },
   /******/ (__webpack_require__) => {
     // webpackRuntimeModules
     /******/ var __webpack_exec__ = (moduleId) =>
       __webpack_require__((__webpack_require__.s = moduleId));
     /******/ __webpack_require__.O(0, [636, 6593, 8792], () =>
-      __webpack_exec__(1651)
+      __webpack_exec__(942)
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for dynamic-HASH.js

@@ -1,177 +1,17 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [2291],
   {
-    /***/ 617: /***/ (
-      __unused_webpack_module,
-      exports,
-      __webpack_require__
-    ) => {
-      "use strict";
-      /* __next_internal_client_entry_do_not_use__  cjs */
-      Object.defineProperty(exports, "__esModule", {
-        value: true,
-      });
-      Object.defineProperty(exports, "LoadableContext", {
-        enumerable: true,
-        get: function () {
-          return LoadableContext;
-        },
-      });
-      const _interop_require_default = __webpack_require__(1532);
-      const _react = /*#__PURE__*/ _interop_require_default._(
-        __webpack_require__(6466)
-      );
-      const LoadableContext = _react.default.createContext(null);
-      if (false) {
-      } //# sourceMappingURL=loadable-context.shared-runtime.js.map
-
-      /***/
-    },
-
-    /***/ 620: /***/ (module, exports, __webpack_require__) => {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true,
-      });
-      0 && 0;
-      function _export(target, all) {
-        for (var name in all)
-          Object.defineProperty(target, name, {
-            enumerable: true,
-            get: all[name],
-          });
-      }
-      _export(exports, {
-        /**
-         * This function lets you dynamically import a component.
-         * It uses [React.lazy()](https://react.dev/reference/react/lazy) with [Suspense](https://react.dev/reference/react/Suspense) under the hood.
-         *
-         * Read more: [Next.js Docs: `next/dynamic`](https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading#nextdynamic)
-         */ default: function () {
-          return dynamic;
-        },
-        noSSR: function () {
-          return noSSR;
-        },
-      });
-      const _interop_require_default = __webpack_require__(1532);
-      const _jsxruntime = __webpack_require__(7002);
-      const _react = /*#__PURE__*/ _interop_require_default._(
-        __webpack_require__(6466)
-      );
-      const _loadablesharedruntime = /*#__PURE__*/ _interop_require_default._(
-        __webpack_require__(3147)
-      );
-      const isServerSide = "object" === "undefined";
-      // Normalize loader to return the module as form { default: Component } for `React.lazy`.
-      // Also for backward compatible since next/dynamic allows to resolve a component directly with loader
-      // Client component reference proxy need to be converted to a module.
-      function convertModule(mod) {
-        return {
-          default: mod?.default || mod,
-        };
-      }
-      function noSSR(LoadableInitializer, loadableOptions) {
-        // Removing webpack and modules means react-loadable won't try preloading
-        delete loadableOptions.webpack;
-        delete loadableOptions.modules;
-        // This check is necessary to prevent react-loadable from initializing on the server
-        if (!isServerSide) {
-          return LoadableInitializer(loadableOptions);
-        }
-        const Loading = loadableOptions.loading;
-        // This will only be rendered on the server side
-        return () =>
-          /*#__PURE__*/ (0, _jsxruntime.jsx)(Loading, {
-            error: null,
-            isLoading: true,
-            pastDelay: false,
-            timedOut: false,
-          });
-      }
-      function dynamic(dynamicOptions, options) {
-        let loadableFn = _loadablesharedruntime.default;
-        let loadableOptions = {
-          // A loading component is not required, so we default it
-          loading: ({ error, isLoading, pastDelay }) => {
-            if (!pastDelay) return null;
-            if (false) {
-            }
-            return null;
-          },
-        };
-        // Support for direct import(), eg: dynamic(import('../hello-world'))
-        // Note that this is only kept for the edge case where someone is passing in a promise as first argument
-        // The react-loadable babel plugin will turn dynamic(import('../hello-world')) into dynamic(() => import('../hello-world'))
-        // To make sure we don't execute the import without rendering first
-        if (dynamicOptions instanceof Promise) {
-          loadableOptions.loader = () => dynamicOptions;
-          // Support for having import as a function, eg: dynamic(() => import('../hello-world'))
-        } else if (typeof dynamicOptions === "function") {
-          loadableOptions.loader = dynamicOptions;
-          // Support for having first argument being options, eg: dynamic({loader: import('../hello-world')})
-        } else if (typeof dynamicOptions === "object") {
-          loadableOptions = {
-            ...loadableOptions,
-            ...dynamicOptions,
-          };
-        }
-        // Support for passing options, eg: dynamic(import('../hello-world'), {loading: () => <p>Loading something</p>})
-        loadableOptions = {
-          ...loadableOptions,
-          ...options,
-        };
-        const loaderFn = loadableOptions.loader;
-        const loader = () =>
-          loaderFn != null
-            ? loaderFn().then(convertModule)
-            : Promise.resolve(convertModule(() => null));
-        // coming from build/babel/plugins/react-loadable-plugin.js
-        if (loadableOptions.loadableGenerated) {
-          loadableOptions = {
-            ...loadableOptions,
-            ...loadableOptions.loadableGenerated,
-          };
-          delete loadableOptions.loadableGenerated;
-        }
-        // support for disabling server side rendering, eg: dynamic(() => import('../hello-world'), {ssr: false}).
-        if (typeof loadableOptions.ssr === "boolean" && !loadableOptions.ssr) {
-          delete loadableOptions.webpack;
-          delete loadableOptions.modules;
-          return noSSR(loadableFn, loadableOptions);
-        }
-        return loadableFn({
-          ...loadableOptions,
-          loader: loader,
-        });
-      }
-      if (
-        (typeof exports.default === "function" ||
-          (typeof exports.default === "object" && exports.default !== null)) &&
-        typeof exports.default.__esModule === "undefined"
-      ) {
-        Object.defineProperty(exports.default, "__esModule", {
-          value: true,
-        });
-        Object.assign(exports.default, exports);
-        module.exports = exports.default;
-      } //# sourceMappingURL=dynamic.js.map
-
-      /***/
-    },
-
-    /***/ 1173: /***/ (
+    /***/ 1151: /***/ (
       module,
       __unused_webpack_exports,
       __webpack_require__
     ) => {
-      module.exports = __webpack_require__(620);
+      module.exports = __webpack_require__(7368);
 
       /***/
     },
 
-    /***/ 2907: /***/ (
+    /***/ 4773: /***/ (
       __unused_webpack_module,
       __webpack_exports__,
       __webpack_require__
@@ -186,7 +26,7 @@
       /* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ =
         __webpack_require__(7002);
       /* harmony import */ var next_dynamic__WEBPACK_IMPORTED_MODULE_1__ =
-        __webpack_require__(1173);
+        __webpack_require__(1151);
       /* harmony import */ var next_dynamic__WEBPACK_IMPORTED_MODULE_1___default =
         /*#__PURE__*/ __webpack_require__.n(
           next_dynamic__WEBPACK_IMPORTED_MODULE_1__
@@ -195,12 +35,12 @@
       const DynamicHello = next_dynamic__WEBPACK_IMPORTED_MODULE_1___default()(
         () =>
           __webpack_require__
-            .e(/* import() */ 9564)
-            .then(__webpack_require__.bind(__webpack_require__, 9564))
+            .e(/* import() */ 6022)
+            .then(__webpack_require__.bind(__webpack_require__, 6022))
             .then((mod) => mod.Hello),
         {
           loadableGenerated: {
-            webpack: () => [/*require.resolve*/ 9564],
+            webpack: () => [/*require.resolve*/ 6022],
           },
         }
       );
@@ -227,7 +67,7 @@
       /***/
     },
 
-    /***/ 3147: /***/ (
+    /***/ 5631: /***/ (
       __unused_webpack_module,
       exports,
       __webpack_require__
@@ -269,7 +109,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
       const _react = /*#__PURE__*/ _interop_require_default._(
         __webpack_require__(6466)
       );
-      const _loadablecontextsharedruntime = __webpack_require__(617);
+      const _loadablecontextsharedruntime = __webpack_require__(6861);
       function resolve(obj) {
         return obj && obj.default ? obj.default : obj;
       }
@@ -502,7 +342,167 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
       /***/
     },
 
-    /***/ 4236: /***/ (
+    /***/ 6861: /***/ (
+      __unused_webpack_module,
+      exports,
+      __webpack_require__
+    ) => {
+      "use strict";
+      /* __next_internal_client_entry_do_not_use__  cjs */
+      Object.defineProperty(exports, "__esModule", {
+        value: true,
+      });
+      Object.defineProperty(exports, "LoadableContext", {
+        enumerable: true,
+        get: function () {
+          return LoadableContext;
+        },
+      });
+      const _interop_require_default = __webpack_require__(1532);
+      const _react = /*#__PURE__*/ _interop_require_default._(
+        __webpack_require__(6466)
+      );
+      const LoadableContext = _react.default.createContext(null);
+      if (false) {
+      } //# sourceMappingURL=loadable-context.shared-runtime.js.map
+
+      /***/
+    },
+
+    /***/ 7368: /***/ (module, exports, __webpack_require__) => {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true,
+      });
+      0 && 0;
+      function _export(target, all) {
+        for (var name in all)
+          Object.defineProperty(target, name, {
+            enumerable: true,
+            get: all[name],
+          });
+      }
+      _export(exports, {
+        /**
+         * This function lets you dynamically import a component.
+         * It uses [React.lazy()](https://react.dev/reference/react/lazy) with [Suspense](https://react.dev/reference/react/Suspense) under the hood.
+         *
+         * Read more: [Next.js Docs: `next/dynamic`](https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading#nextdynamic)
+         */ default: function () {
+          return dynamic;
+        },
+        noSSR: function () {
+          return noSSR;
+        },
+      });
+      const _interop_require_default = __webpack_require__(1532);
+      const _jsxruntime = __webpack_require__(7002);
+      const _react = /*#__PURE__*/ _interop_require_default._(
+        __webpack_require__(6466)
+      );
+      const _loadablesharedruntime = /*#__PURE__*/ _interop_require_default._(
+        __webpack_require__(5631)
+      );
+      const isServerSide = "object" === "undefined";
+      // Normalize loader to return the module as form { default: Component } for `React.lazy`.
+      // Also for backward compatible since next/dynamic allows to resolve a component directly with loader
+      // Client component reference proxy need to be converted to a module.
+      function convertModule(mod) {
+        return {
+          default: mod?.default || mod,
+        };
+      }
+      function noSSR(LoadableInitializer, loadableOptions) {
+        // Removing webpack and modules means react-loadable won't try preloading
+        delete loadableOptions.webpack;
+        delete loadableOptions.modules;
+        // This check is necessary to prevent react-loadable from initializing on the server
+        if (!isServerSide) {
+          return LoadableInitializer(loadableOptions);
+        }
+        const Loading = loadableOptions.loading;
+        // This will only be rendered on the server side
+        return () =>
+          /*#__PURE__*/ (0, _jsxruntime.jsx)(Loading, {
+            error: null,
+            isLoading: true,
+            pastDelay: false,
+            timedOut: false,
+          });
+      }
+      function dynamic(dynamicOptions, options) {
+        let loadableFn = _loadablesharedruntime.default;
+        let loadableOptions = {
+          // A loading component is not required, so we default it
+          loading: ({ error, isLoading, pastDelay }) => {
+            if (!pastDelay) return null;
+            if (false) {
+            }
+            return null;
+          },
+        };
+        // Support for direct import(), eg: dynamic(import('../hello-world'))
+        // Note that this is only kept for the edge case where someone is passing in a promise as first argument
+        // The react-loadable babel plugin will turn dynamic(import('../hello-world')) into dynamic(() => import('../hello-world'))
+        // To make sure we don't execute the import without rendering first
+        if (dynamicOptions instanceof Promise) {
+          loadableOptions.loader = () => dynamicOptions;
+          // Support for having import as a function, eg: dynamic(() => import('../hello-world'))
+        } else if (typeof dynamicOptions === "function") {
+          loadableOptions.loader = dynamicOptions;
+          // Support for having first argument being options, eg: dynamic({loader: import('../hello-world')})
+        } else if (typeof dynamicOptions === "object") {
+          loadableOptions = {
+            ...loadableOptions,
+            ...dynamicOptions,
+          };
+        }
+        // Support for passing options, eg: dynamic(import('../hello-world'), {loading: () => <p>Loading something</p>})
+        loadableOptions = {
+          ...loadableOptions,
+          ...options,
+        };
+        const loaderFn = loadableOptions.loader;
+        const loader = () =>
+          loaderFn != null
+            ? loaderFn().then(convertModule)
+            : Promise.resolve(convertModule(() => null));
+        // coming from build/babel/plugins/react-loadable-plugin.js
+        if (loadableOptions.loadableGenerated) {
+          loadableOptions = {
+            ...loadableOptions,
+            ...loadableOptions.loadableGenerated,
+          };
+          delete loadableOptions.loadableGenerated;
+        }
+        // support for disabling server side rendering, eg: dynamic(() => import('../hello-world'), {ssr: false}).
+        if (typeof loadableOptions.ssr === "boolean" && !loadableOptions.ssr) {
+          delete loadableOptions.webpack;
+          delete loadableOptions.modules;
+          return noSSR(loadableFn, loadableOptions);
+        }
+        return loadableFn({
+          ...loadableOptions,
+          loader: loader,
+        });
+      }
+      if (
+        (typeof exports.default === "function" ||
+          (typeof exports.default === "object" && exports.default !== null)) &&
+        typeof exports.default.__esModule === "undefined"
+      ) {
+        Object.defineProperty(exports.default, "__esModule", {
+          value: true,
+        });
+        Object.assign(exports.default, exports);
+        module.exports = exports.default;
+      } //# sourceMappingURL=dynamic.js.map
+
+      /***/
+    },
+
+    /***/ 8258: /***/ (
       __unused_webpack_module,
       __unused_webpack_exports,
       __webpack_require__
@@ -510,7 +510,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
       (window.__NEXT_P = window.__NEXT_P || []).push([
         "/dynamic",
         function () {
-          return __webpack_require__(2907);
+          return __webpack_require__(4773);
         },
       ]);
       if (false) {
@@ -524,7 +524,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
     /******/ var __webpack_exec__ = (moduleId) =>
       __webpack_require__((__webpack_require__.s = moduleId));
     /******/ __webpack_require__.O(0, [636, 6593, 8792], () =>
-      __webpack_exec__(4236)
+      __webpack_exec__(8258)
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for head-HASH.js

@@ -1,24 +1,13 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [5350],
   {
-    /***/ 2366: /***/ (
-      __unused_webpack_module,
-      __unused_webpack_exports,
-      __webpack_require__
-    ) => {
-      (window.__NEXT_P = window.__NEXT_P || []).push([
-        "/head",
-        function () {
-          return __webpack_require__(8140);
-        },
-      ]);
-      if (false) {
-      }
+    /***/ 48: /***/ (module, __unused_webpack_exports, __webpack_require__) => {
+      module.exports = __webpack_require__(8141);
 
       /***/
     },
 
-    /***/ 8140: /***/ (
+    /***/ 2682: /***/ (
       __unused_webpack_module,
       __webpack_exports__,
       __webpack_require__
@@ -33,7 +22,7 @@
       /* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ =
         __webpack_require__(7002);
       /* harmony import */ var next_head__WEBPACK_IMPORTED_MODULE_1__ =
-        __webpack_require__(9386);
+        __webpack_require__(48);
       /* harmony import */ var next_head__WEBPACK_IMPORTED_MODULE_1___default =
         /*#__PURE__*/ __webpack_require__.n(
           next_head__WEBPACK_IMPORTED_MODULE_1__
@@ -67,12 +56,19 @@
       /***/
     },
 
-    /***/ 9386: /***/ (
-      module,
+    /***/ 2956: /***/ (
+      __unused_webpack_module,
       __unused_webpack_exports,
       __webpack_require__
     ) => {
-      module.exports = __webpack_require__(1649);
+      (window.__NEXT_P = window.__NEXT_P || []).push([
+        "/head",
+        function () {
+          return __webpack_require__(2682);
+        },
+      ]);
+      if (false) {
+      }
 
       /***/
     },
@@ -82,7 +78,7 @@
     /******/ var __webpack_exec__ = (moduleId) =>
       __webpack_require__((__webpack_require__.s = moduleId));
     /******/ __webpack_require__.O(0, [636, 6593, 8792], () =>
-      __webpack_exec__(2366)
+      __webpack_exec__(2956)
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for image-HASH.js

@@ -1,7 +1,24 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [2983],
   {
-    /***/ 497: /***/ (
+    /***/ 8114: /***/ (
+      __unused_webpack_module,
+      __unused_webpack_exports,
+      __webpack_require__
+    ) => {
+      (window.__NEXT_P = window.__NEXT_P || []).push([
+        "/image",
+        function () {
+          return __webpack_require__(9180);
+        },
+      ]);
+      if (false) {
+      }
+
+      /***/
+    },
+
+    /***/ 9180: /***/ (
       __unused_webpack_module,
       __webpack_exports__,
       __webpack_require__
@@ -18,8 +35,8 @@
 
       // EXTERNAL MODULE: ./node_modules/.pnpm/react@19.2.1/node_modules/react/jsx-runtime.js
       var jsx_runtime = __webpack_require__(7002);
-      // EXTERNAL MODULE: ./node_modules/.pnpm/next@file+..+main-repo+packages+next+next-packed.tgz_react-dom@19.2.1_react@19.2.1__react@19.2.1/node_modules/next/image.js
-      var next_image = __webpack_require__(9565);
+      // EXTERNAL MODULE: ./node_modules/.pnpm/next@file+..+diff-repo+packages+next+next-packed.tgz_react-dom@19.2.1_react@19.2.1__react@19.2.1/node_modules/next/image.js
+      var next_image = __webpack_require__(5467);
       var image_default = /*#__PURE__*/ __webpack_require__.n(next_image); // ./pages/nextjs.png
       /* harmony default export */ const nextjs = {
         src: "/_next/static/media/nextjs.cae0b805.png",
@@ -48,30 +65,13 @@
 
       /***/
     },
-
-    /***/ 5748: /***/ (
-      __unused_webpack_module,
-      __unused_webpack_exports,
-      __webpack_require__
-    ) => {
-      (window.__NEXT_P = window.__NEXT_P || []).push([
-        "/image",
-        function () {
-          return __webpack_require__(497);
-        },
-      ]);
-      if (false) {
-      }
-
-      /***/
-    },
   },
   /******/ (__webpack_require__) => {
     // webpackRuntimeModules
     /******/ var __webpack_exec__ = (moduleId) =>
       __webpack_require__((__webpack_require__.s = moduleId));
-    /******/ __webpack_require__.O(0, [9565, 636, 6593, 8792], () =>
-      __webpack_exec__(5748)
+    /******/ __webpack_require__.O(0, [5467, 636, 6593, 8792], () =>
+      __webpack_exec__(8114)
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for link-HASH.js

@@ -1,7 +1,7 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [4672],
   {
-    /***/ 1182: /***/ (
+    /***/ 2156: /***/ (
       __unused_webpack_module,
       __unused_webpack_exports,
       __webpack_require__
@@ -9,7 +9,7 @@
       (window.__NEXT_P = window.__NEXT_P || []).push([
         "/link",
         function () {
-          return __webpack_require__(4610);
+          return __webpack_require__(8272);
         },
       ]);
       if (false) {
@@ -18,7 +18,220 @@
       /***/
     },
 
-    /***/ 1557: /***/ (module, exports, __webpack_require__) => {
+    /***/ 4581: /***/ (module, exports, __webpack_require__) => {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true,
+      });
+      Object.defineProperty(exports, "useIntersection", {
+        enumerable: true,
+        get: function () {
+          return useIntersection;
+        },
+      });
+      const _react = __webpack_require__(6466);
+      const _requestidlecallback = __webpack_require__(7441);
+      const hasIntersectionObserver =
+        typeof IntersectionObserver === "function";
+      const observers = new Map();
+      const idList = [];
+      function createObserver(options) {
+        const id = {
+          root: options.root || null,
+          margin: options.rootMargin || "",
+        };
+        const existing = idList.find(
+          (obj) => obj.root === id.root && obj.margin === id.margin
+        );
+        let instance;
+        if (existing) {
+          instance = observers.get(existing);
+          if (instance) {
+            return instance;
+          }
+        }
+        const elements = new Map();
+        const observer = new IntersectionObserver((entries) => {
+          entries.forEach((entry) => {
+            const callback = elements.get(entry.target);
+            const isVisible =
+              entry.isIntersecting || entry.intersectionRatio > 0;
+            if (callback && isVisible) {
+              callback(isVisible);
+            }
+          });
+        }, options);
+        instance = {
+          id,
+          observer,
+          elements,
+        };
+        idList.push(id);
+        observers.set(id, instance);
+        return instance;
+      }
+      function observe(element, callback, options) {
+        const { id, observer, elements } = createObserver(options);
+        elements.set(element, callback);
+        observer.observe(element);
+        return function unobserve() {
+          elements.delete(element);
+          observer.unobserve(element);
+          // Destroy observer when there's nothing left to watch:
+          if (elements.size === 0) {
+            observer.disconnect();
+            observers.delete(id);
+            const index = idList.findIndex(
+              (obj) => obj.root === id.root && obj.margin === id.margin
+            );
+            if (index > -1) {
+              idList.splice(index, 1);
+            }
+          }
+        };
+      }
+      function useIntersection({ rootRef, rootMargin, disabled }) {
+        const isDisabled = disabled || !hasIntersectionObserver;
+        const [visible, setVisible] = (0, _react.useState)(false);
+        const elementRef = (0, _react.useRef)(null);
+        const setElement = (0, _react.useCallback)((element) => {
+          elementRef.current = element;
+        }, []);
+        (0, _react.useEffect)(() => {
+          if (hasIntersectionObserver) {
+            if (isDisabled || visible) return;
+            const element = elementRef.current;
+            if (element && element.tagName) {
+              const unobserve = observe(
+                element,
+                (isVisible) => isVisible && setVisible(isVisible),
+                {
+                  root: rootRef?.current,
+                  rootMargin,
+                }
+              );
+              return unobserve;
+            }
+          } else {
+            if (!visible) {
+              const idleCallback = (0,
+              _requestidlecallback.requestIdleCallback)(() => setVisible(true));
+              return () =>
+                (0, _requestidlecallback.cancelIdleCallback)(idleCallback);
+            }
+          }
+          // eslint-disable-next-line react-hooks/exhaustive-deps
+        }, [isDisabled, rootMargin, rootRef, visible, elementRef.current]);
+        const resetVisible = (0, _react.useCallback)(() => {
+          setVisible(false);
+        }, []);
+        return [setElement, visible, resetVisible];
+      }
+      if (
+        (typeof exports.default === "function" ||
+          (typeof exports.default === "object" && exports.default !== null)) &&
+        typeof exports.default.__esModule === "undefined"
+      ) {
+        Object.defineProperty(exports.default, "__esModule", {
+          value: true,
+        });
+        Object.assign(exports.default, exports);
+        module.exports = exports.default;
+      } //# sourceMappingURL=use-intersection.js.map
+
+      /***/
+    },
+
+    /***/ 6155: /***/ (module, exports, __webpack_require__) => {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true,
+      });
+      Object.defineProperty(exports, "useMergedRef", {
+        enumerable: true,
+        get: function () {
+          return useMergedRef;
+        },
+      });
+      const _react = __webpack_require__(6466);
+      function useMergedRef(refA, refB) {
+        const cleanupA = (0, _react.useRef)(null);
+        const cleanupB = (0, _react.useRef)(null);
+        // NOTE: In theory, we could skip the wrapping if only one of the refs is non-null.
+        // (this happens often if the user doesn't pass a ref to Link/Form/Image)
+        // But this can cause us to leak a cleanup-ref into user code (previously via `<Link legacyBehavior>`),
+        // and the user might pass that ref into ref-merging library that doesn't support cleanup refs
+        // (because it hasn't been updated for React 19)
+        // which can then cause things to blow up, because a cleanup-returning ref gets called with `null`.
+        // So in practice, it's safer to be defensive and always wrap the ref, even on React 19.
+        return (0, _react.useCallback)(
+          (current) => {
+            if (current === null) {
+              const cleanupFnA = cleanupA.current;
+              if (cleanupFnA) {
+                cleanupA.current = null;
+                cleanupFnA();
+              }
+              const cleanupFnB = cleanupB.current;
+              if (cleanupFnB) {
+                cleanupB.current = null;
+                cleanupFnB();
+              }
+            } else {
+              if (refA) {
+                cleanupA.current = applyRef(refA, current);
+              }
+              if (refB) {
+                cleanupB.current = applyRef(refB, current);
+              }
+            }
+          },
+          [refA, refB]
+        );
+      }
+      function applyRef(refA, current) {
+        if (typeof refA === "function") {
+          const cleanup = refA(current);
+          if (typeof cleanup === "function") {
+            return cleanup;
+          } else {
+            return () => refA(null);
+          }
+        } else {
+          refA.current = current;
+          return () => {
+            refA.current = null;
+          };
+        }
+      }
+      if (
+        (typeof exports.default === "function" ||
+          (typeof exports.default === "object" && exports.default !== null)) &&
+        typeof exports.default.__esModule === "undefined"
+      ) {
+        Object.defineProperty(exports.default, "__esModule", {
+          value: true,
+        });
+        Object.assign(exports.default, exports);
+        module.exports = exports.default;
+      } //# sourceMappingURL=use-merged-ref.js.map
+
+      /***/
+    },
+
+    /***/ 7046: /***/ (
+      module,
+      __unused_webpack_exports,
+      __webpack_require__
+    ) => {
+      module.exports = __webpack_require__(8113);
+
+      /***/
+    },
+
+    /***/ 8113: /***/ (module, exports, __webpack_require__) => {
       "use strict";
       /* __next_internal_client_entry_do_not_use__  cjs */
       Object.defineProperty(exports, "__esModule", {
@@ -45,17 +258,17 @@
       const _react = /*#__PURE__*/ _interop_require_wildcard._(
         __webpack_require__(6466)
       );
-      const _resolvehref = __webpack_require__(5475);
-      const _islocalurl = __webpack_require__(6475);
-      const _formaturl = __webpack_require__(9998);
-      const _utils = __webpack_require__(3084);
-      const _addlocale = __webpack_require__(3921);
-      const _routercontextsharedruntime = __webpack_require__(7726);
-      const _useintersection = __webpack_require__(4806);
-      const _getdomainlocale = __webpack_require__(3219);
-      const _addbasepath = __webpack_require__(5498);
-      const _usemergedref = __webpack_require__(3255);
-      const _erroronce = __webpack_require__(1685);
+      const _resolvehref = __webpack_require__(2399);
+      const _islocalurl = __webpack_require__(6687);
+      const _formaturl = __webpack_require__(4802);
+      const _utils = __webpack_require__(9208);
+      const _addlocale = __webpack_require__(9845);
+      const _routercontextsharedruntime = __webpack_require__(3466);
+      const _useintersection = __webpack_require__(4581);
+      const _getdomainlocale = __webpack_require__(8319);
+      const _addbasepath = __webpack_require__(4126);
+      const _usemergedref = __webpack_require__(6155);
+      const _erroronce = __webpack_require__(8305);
       const prefetched = new Set();
       function prefetch(router, href, as, options) {
         if (false) {
@@ -434,140 +647,7 @@
       /***/
     },
 
-    /***/ 1685: /***/ (__unused_webpack_module, exports) => {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true,
-      });
-      Object.defineProperty(exports, "errorOnce", {
-        enumerable: true,
-        get: function () {
-          return errorOnce;
-        },
-      });
-      let errorOnce = (_) => {};
-      if (false) {
-      } //# sourceMappingURL=error-once.js.map
-
-      /***/
-    },
-
-    /***/ 3219: /***/ (module, exports, __webpack_require__) => {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true,
-      });
-      Object.defineProperty(exports, "getDomainLocale", {
-        enumerable: true,
-        get: function () {
-          return getDomainLocale;
-        },
-      });
-      const _normalizetrailingslash = __webpack_require__(1059);
-      const basePath =
-        /* unused pure expression or super */ null && (false || "");
-      function getDomainLocale(path, locale, locales, domainLocales) {
-        if (false) {
-        } else {
-          return false;
-        }
-      }
-      if (
-        (typeof exports.default === "function" ||
-          (typeof exports.default === "object" && exports.default !== null)) &&
-        typeof exports.default.__esModule === "undefined"
-      ) {
-        Object.defineProperty(exports.default, "__esModule", {
-          value: true,
-        });
-        Object.assign(exports.default, exports);
-        module.exports = exports.default;
-      } //# sourceMappingURL=get-domain-locale.js.map
-
-      /***/
-    },
-
-    /***/ 3255: /***/ (module, exports, __webpack_require__) => {
-      "use strict";
-
-      Object.defineProperty(exports, "__esModule", {
-        value: true,
-      });
-      Object.defineProperty(exports, "useMergedRef", {
-        enumerable: true,
-        get: function () {
-          return useMergedRef;
-        },
-      });
-      const _react = __webpack_require__(6466);
-      function useMergedRef(refA, refB) {
-        const cleanupA = (0, _react.useRef)(null);
-        const cleanupB = (0, _react.useRef)(null);
-        // NOTE: In theory, we could skip the wrapping if only one of the refs is non-null.
-        // (this happens often if the user doesn't pass a ref to Link/Form/Image)
-        // But this can cause us to leak a cleanup-ref into user code (previously via `<Link legacyBehavior>`),
-        // and the user might pass that ref into ref-merging library that doesn't support cleanup refs
-        // (because it hasn't been updated for React 19)
-        // which can then cause things to blow up, because a cleanup-returning ref gets called with `null`.
-        // So in practice, it's safer to be defensive and always wrap the ref, even on React 19.
-        return (0, _react.useCallback)(
-          (current) => {
-            if (current === null) {
-              const cleanupFnA = cleanupA.current;
-              if (cleanupFnA) {
-                cleanupA.current = null;
-                cleanupFnA();
-              }
-              const cleanupFnB = cleanupB.current;
-              if (cleanupFnB) {
-                cleanupB.current = null;
-                cleanupFnB();
-              }
-            } else {
-              if (refA) {
-                cleanupA.current = applyRef(refA, current);
-              }
-              if (refB) {
-                cleanupB.current = applyRef(refB, current);
-              }
-            }
-          },
-          [refA, refB]
-        );
-      }
-      function applyRef(refA, current) {
-        if (typeof refA === "function") {
-          const cleanup = refA(current);
-          if (typeof cleanup === "function") {
-            return cleanup;
-          } else {
-            return () => refA(null);
-          }
-        } else {
-          refA.current = current;
-          return () => {
-            refA.current = null;
-          };
-        }
-      }
-      if (
-        (typeof exports.default === "function" ||
-          (typeof exports.default === "object" && exports.default !== null)) &&
-        typeof exports.default.__esModule === "undefined"
-      ) {
-        Object.defineProperty(exports.default, "__esModule", {
-          value: true,
-        });
-        Object.assign(exports.default, exports);
-        module.exports = exports.default;
-      } //# sourceMappingURL=use-merged-ref.js.map
-
-      /***/
-    },
-
-    /***/ 4610: /***/ (
+    /***/ 8272: /***/ (
       __unused_webpack_module,
       __webpack_exports__,
       __webpack_require__
@@ -582,7 +662,7 @@
       /* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ =
         __webpack_require__(7002);
       /* harmony import */ var next_link__WEBPACK_IMPORTED_MODULE_1__ =
-        __webpack_require__(9056);
+        __webpack_require__(7046);
       /* harmony import */ var next_link__WEBPACK_IMPORTED_MODULE_1___default =
         /*#__PURE__*/ __webpack_require__.n(
           next_link__WEBPACK_IMPORTED_MODULE_1__
@@ -613,115 +693,45 @@
       /***/
     },
 
-    /***/ 4806: /***/ (module, exports, __webpack_require__) => {
+    /***/ 8305: /***/ (__unused_webpack_module, exports) => {
       "use strict";
 
       Object.defineProperty(exports, "__esModule", {
         value: true,
       });
-      Object.defineProperty(exports, "useIntersection", {
+      Object.defineProperty(exports, "errorOnce", {
         enumerable: true,
         get: function () {
-          return useIntersection;
+          return errorOnce;
         },
       });
-      const _react = __webpack_require__(6466);
-      const _requestidlecallback = __webpack_require__(805);
-      const hasIntersectionObserver =
-        typeof IntersectionObserver === "function";
-      const observers = new Map();
-      const idList = [];
-      function createObserver(options) {
-        const id = {
-          root: options.root || null,
-          margin: options.rootMargin || "",
-        };
-        const existing = idList.find(
-          (obj) => obj.root === id.root && obj.margin === id.margin
-        );
-        let instance;
-        if (existing) {
-          instance = observers.get(existing);
-          if (instance) {
-            return instance;
-          }
+      let errorOnce = (_) => {};
+      if (false) {
+      } //# sourceMappingURL=error-once.js.map
+
+      /***/
+    },
+
+    /***/ 8319: /***/ (module, exports, __webpack_require__) => {
+      "use strict";
+
+      Object.defineProperty(exports, "__esModule", {
+        value: true,
+      });
+      Object.defineProperty(exports, "getDomainLocale", {
+        enumerable: true,
+        get: function () {
+          return getDomainLocale;
+        },
+      });
+      const _normalizetrailingslash = __webpack_require__(6063);
+      const basePath =
+        /* unused pure expression or super */ null && (false || "");
+      function getDomainLocale(path, locale, locales, domainLocales) {
+        if (false) {
+        } else {
+          return false;
         }
-        const elements = new Map();
-        const observer = new IntersectionObserver((entries) => {
-          entries.forEach((entry) => {
-            const callback = elements.get(entry.target);
-            const isVisible =
-              entry.isIntersecting || entry.intersectionRatio > 0;
-            if (callback && isVisible) {
-              callback(isVisible);
-            }
-          });
-        }, options);
-        instance = {
-          id,
-          observer,
-          elements,
-        };
-        idList.push(id);
-        observers.set(id, instance);
-        return instance;
-      }
-      function observe(element, callback, options) {
-        const { id, observer, elements } = createObserver(options);
-        elements.set(element, callback);
-        observer.observe(element);
-        return function unobserve() {
-          elements.delete(element);
-          observer.unobserve(element);
-          // Destroy observer when there's nothing left to watch:
-          if (elements.size === 0) {
-            observer.disconnect();
-            observers.delete(id);
-            const index = idList.findIndex(
-              (obj) => obj.root === id.root && obj.margin === id.margin
-            );
-            if (index > -1) {
-              idList.splice(index, 1);
-            }
-          }
-        };
-      }
-      function useIntersection({ rootRef, rootMargin, disabled }) {
-        const isDisabled = disabled || !hasIntersectionObserver;
-        const [visible, setVisible] = (0, _react.useState)(false);
-        const elementRef = (0, _react.useRef)(null);
-        const setElement = (0, _react.useCallback)((element) => {
-          elementRef.current = element;
-        }, []);
-        (0, _react.useEffect)(() => {
-          if (hasIntersectionObserver) {
-            if (isDisabled || visible) return;
-            const element = elementRef.current;
-            if (element && element.tagName) {
-              const unobserve = observe(
-                element,
-                (isVisible) => isVisible && setVisible(isVisible),
-                {
-                  root: rootRef?.current,
-                  rootMargin,
-                }
-              );
-              return unobserve;
-            }
-          } else {
-            if (!visible) {
-              const idleCallback = (0,
-              _requestidlecallback.requestIdleCallback)(() => setVisible(true));
-              return () =>
-                (0, _requestidlecallback.cancelIdleCallback)(idleCallback);
-            }
-          }
-          // eslint-disable-next-line react-hooks/exhaustive-deps
-        }, [isDisabled, rootMargin, rootRef, visible, elementRef.current]);
-        const resetVisible = (0, _react.useCallback)(() => {
-          setVisible(false);
-        }, []);
-        return [setElement, visible, resetVisible];
       }
       if (
         (typeof exports.default === "function" ||
@@ -733,17 +743,7 @@
         });
         Object.assign(exports.default, exports);
         module.exports = exports.default;
-      } //# sourceMappingURL=use-intersection.js.map
-
-      /***/
-    },
-
-    /***/ 9056: /***/ (
-      module,
-      __unused_webpack_exports,
-      __webpack_require__
-    ) => {
-      module.exports = __webpack_require__(1557);
+      } //# sourceMappingURL=get-domain-locale.js.map
 
       /***/
     },
@@ -753,7 +753,7 @@
     /******/ var __webpack_exec__ = (moduleId) =>
       __webpack_require__((__webpack_require__.s = moduleId));
     /******/ __webpack_require__.O(0, [636, 6593, 8792], () =>
-      __webpack_exec__(1182)
+      __webpack_exec__(2156)
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for script-HASH.js

@@ -1,13 +1,7 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [1209],
   {
-    /***/ 15: /***/ (module, __unused_webpack_exports, __webpack_require__) => {
-      module.exports = __webpack_require__(5258);
-
-      /***/
-    },
-
-    /***/ 6853: /***/ (
+    /***/ 2895: /***/ (
       __unused_webpack_module,
       __webpack_exports__,
       __webpack_require__
@@ -22,7 +16,7 @@
       /* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ =
         __webpack_require__(7002);
       /* harmony import */ var next_script__WEBPACK_IMPORTED_MODULE_1__ =
-        __webpack_require__(15);
+        __webpack_require__(3489);
       /* harmony import */ var next_script__WEBPACK_IMPORTED_MODULE_1___default =
         /*#__PURE__*/ __webpack_require__.n(
           next_script__WEBPACK_IMPORTED_MODULE_1__
@@ -55,7 +49,17 @@
       /***/
     },
 
-    /***/ 9264: /***/ (
+    /***/ 3489: /***/ (
+      module,
+      __unused_webpack_exports,
+      __webpack_require__
+    ) => {
+      module.exports = __webpack_require__(3102);
+
+      /***/
+    },
+
+    /***/ 9884: /***/ (
       __unused_webpack_module,
       __unused_webpack_exports,
       __webpack_require__
@@ -63,7 +67,7 @@
       (window.__NEXT_P = window.__NEXT_P || []).push([
         "/script",
         function () {
-          return __webpack_require__(6853);
+          return __webpack_require__(2895);
         },
       ]);
       if (false) {
@@ -77,7 +81,7 @@
     /******/ var __webpack_exec__ = (moduleId) =>
       __webpack_require__((__webpack_require__.s = moduleId));
     /******/ __webpack_require__.O(0, [636, 6593, 8792], () =>
-      __webpack_exec__(9264)
+      __webpack_exec__(9884)
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for withRouter-HASH.js

@@ -1,34 +1,7 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [3263],
   {
-    /***/ 1593: /***/ (
-      module,
-      __unused_webpack_exports,
-      __webpack_require__
-    ) => {
-      module.exports = __webpack_require__(372);
-
-      /***/
-    },
-
-    /***/ 4550: /***/ (
-      __unused_webpack_module,
-      __unused_webpack_exports,
-      __webpack_require__
-    ) => {
-      (window.__NEXT_P = window.__NEXT_P || []).push([
-        "/withRouter",
-        function () {
-          return __webpack_require__(8527);
-        },
-      ]);
-      if (false) {
-      }
-
-      /***/
-    },
-
-    /***/ 8527: /***/ (
+    /***/ 69: /***/ (
       __unused_webpack_module,
       __webpack_exports__,
       __webpack_require__
@@ -43,7 +16,7 @@
       /* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ =
         __webpack_require__(7002);
       /* harmony import */ var next_router__WEBPACK_IMPORTED_MODULE_1__ =
-        __webpack_require__(1593);
+        __webpack_require__(2027);
       /* harmony import */ var next_router__WEBPACK_IMPORTED_MODULE_1___default =
         /*#__PURE__*/ __webpack_require__.n(
           next_router__WEBPACK_IMPORTED_MODULE_1__
@@ -61,13 +34,40 @@
 
       /***/
     },
+
+    /***/ 2027: /***/ (
+      module,
+      __unused_webpack_exports,
+      __webpack_require__
+    ) => {
+      module.exports = __webpack_require__(1536);
+
+      /***/
+    },
+
+    /***/ 2268: /***/ (
+      __unused_webpack_module,
+      __unused_webpack_exports,
+      __webpack_require__
+    ) => {
+      (window.__NEXT_P = window.__NEXT_P || []).push([
+        "/withRouter",
+        function () {
+          return __webpack_require__(69);
+        },
+      ]);
+      if (false) {
+      }
+
+      /***/
+    },
   },
   /******/ (__webpack_require__) => {
     // webpackRuntimeModules
     /******/ var __webpack_exec__ = (moduleId) =>
       __webpack_require__((__webpack_require__.s = moduleId));
     /******/ __webpack_require__.O(0, [636, 6593, 8792], () =>
-      __webpack_exec__(4550)
+      __webpack_exec__(2268)
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for 4951-HASH.js

Diff too large to display

Diff for 8034-HASH.js

failed to diff

Diff for 9565-HASH.js

Diff too large to display

Diff for main-HASH.js

Diff too large to display

Diff for main-app-HASH.js

@@ -1,64 +1,64 @@
 (self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([
   [4977],
   {
-    /***/ 3643: /***/ () => {
-      /* (ignored) */
-      /***/
-    },
-
-    /***/ 4139: /***/ (
+    /***/ 591: /***/ (
       __unused_webpack_module,
       __unused_webpack_exports,
       __webpack_require__
     ) => {
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 5065, 23)
+        __webpack_require__.t.bind(__webpack_require__, 2467, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 8974, 23)
+        __webpack_require__.t.bind(__webpack_require__, 8296, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 6506, 23)
+        __webpack_require__.t.bind(__webpack_require__, 488, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 1, 23)
+        __webpack_require__.t.bind(__webpack_require__, 6887, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 8239, 23)
+        __webpack_require__.t.bind(__webpack_require__, 1753, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 1187, 23)
+        __webpack_require__.t.bind(__webpack_require__, 3265, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 7790, 23)
+        __webpack_require__.t.bind(__webpack_require__, 1848, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 6543, 23)
+        __webpack_require__.t.bind(__webpack_require__, 565, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 5802, 23)
+        __webpack_require__.t.bind(__webpack_require__, 6732, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 2809, 23)
+        __webpack_require__.t.bind(__webpack_require__, 6439, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 5738, 23)
+        __webpack_require__.t.bind(__webpack_require__, 228, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.bind(__webpack_require__, 5455)
+        __webpack_require__.bind(__webpack_require__, 3013)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 4731, 23)
+        __webpack_require__.t.bind(__webpack_require__, 8253, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 3753, 23)
+        __webpack_require__.t.bind(__webpack_require__, 3772, 23)
       );
       Promise.resolve(/* import() eager */).then(
-        __webpack_require__.t.bind(__webpack_require__, 2816, 23)
+        __webpack_require__.t.bind(__webpack_require__, 5846, 23)
       );
 
       /***/
     },
+
+    /***/ 905: /***/ () => {
+      /* (ignored) */
+      /***/
+    },
   },
   /******/ (__webpack_require__) => {
     // webpackRuntimeModules
@@ -66,8 +66,8 @@
       __webpack_require__((__webpack_require__.s = moduleId));
     /******/ __webpack_require__.O(
       0,
-      [119, 8034],
-      () => (__webpack_exec__(5111), __webpack_exec__(4139))
+      [4246, 2914],
+      () => (__webpack_exec__(1429), __webpack_exec__(591))
     );
     /******/ var __webpack_exports__ = __webpack_require__.O();
     /******/ _N_E = __webpack_exports__;

Diff for app-page-exp..ntime.dev.js

failed to diff

Diff for app-page-tur..ntime.dev.js

failed to diff

Diff for app-page-tur..ntime.dev.js

failed to diff

Diff for app-page.runtime.dev.js

failed to diff

Diff for app-route-ex..ntime.dev.js

Diff too large to display

Diff for app-route-tu..ntime.dev.js

Diff too large to display

Diff for app-route-tu..ntime.dev.js

Diff too large to display

Diff for app-route.runtime.dev.js

Diff too large to display

Diff for pages-api-tu..ntime.dev.js

Diff too large to display

Diff for pages-api.runtime.dev.js

Diff too large to display

Diff for pages-turbo...ntime.dev.js

Diff too large to display

Diff for pages.runtime.dev.js

Diff too large to display

Commit: e138bc7

[ijjk]

Allow CI Workflow Run

• approve CI run for commit: 4dee567

Note: this should only be enabled once the PR is ready to go and can only be enabled by a maintainer