first commit

test/integration/prerender-export/next.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  output: 'export',
+  exportTrailingSlash: true,
+  exportPathMap: function (defaultPathMap) {
+    if (defaultPathMap['/blog/[post]']) {
+      throw new Error('Found Incremental page in the default export path map')
+    }
+    return defaultPathMap
+  },
+}

test/integration/prerender-export/pages/another/index.js

@@ -0,0 +1,29 @@
+import Link from 'next/link'
+import fs from 'fs'
+import path from 'path'
+
+export async function getStaticProps() {
+  const text = fs
+    .readFileSync(path.join(process.cwd(), 'world.txt'), 'utf8')
+    .trim()
+  return {
+    props: {
+      world: text,
+      time: new Date().getTime(),
+    },
+  }
+}
+
+export default ({ world, time }) => (
+  <>
+    <p>hello {world}</p>
+    <span id="anotherTime">time: {time}</span>
+    <Link href="/" id="home">
+      to home
+    </Link>
+    <br />
+    <Link href="/something" id="something">
+      to something
+    </Link>
+  </>
+)

test/integration/prerender-export/pages/api-docs/[...slug].js

@@ -0,0 +1,27 @@
+import { useRouter } from 'next/router'
+
+export const getStaticProps = () => {
+  return {
+    props: {
+      hello: 'world',
+    },
+  }
+}
+
+export const getStaticPaths = () => {
+  return {
+    paths: ['/api-docs/first'],
+    fallback: false,
+  }
+}
+
+export default function Slug(props) {
+  if (useRouter().isFallback) return 'Loading...'
+
+  return (
+    <>
+      <p id="api-docs">API Docs</p>
+      <p id="props">{JSON.stringify(props)}</p>
+    </>
+  )
+}

test/integration/prerender-export/pages/api/bad.js

@@ -0,0 +1,3 @@
+export default function handler(req, res) {
+  throw new Error('lol')
+}

test/integration/prerender-export/pages/blocking-fallback-once/[slug].js

@@ -0,0 +1,42 @@
+import React from 'react'
+import Link from 'next/link'
+import { useRouter } from 'next/router'
+
+export async function getStaticPaths() {
+  return {
+    paths: [],
+    fallback: false,
+  }
+}
+
+export async function getStaticProps({ params }) {
+  await new Promise((resolve) => setTimeout(resolve, 1000))
+
+  return {
+    props: {
+      params,
+      hello: 'world',
+      post: params.slug,
+      random: Math.random(),
+      time: (await import('perf_hooks')).performance.now(),
+    },
+  }
+}
+
+export default ({ post, time, params }) => {
+  if (useRouter().isFallback) {
+    return <p>hi fallback</p>
+  }
+
+  return (
+    <>
+      <p>Post: {post}</p>
+      <span>time: {time}</span>
+      <div id="params">{JSON.stringify(params)}</div>
+      <div id="query">{JSON.stringify(useRouter().query)}</div>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/blocking-fallback-some/[slug].js

@@ -0,0 +1,42 @@
+import React from 'react'
+import Link from 'next/link'
+import { useRouter } from 'next/router'
+
+export async function getStaticPaths() {
+  return {
+    paths: [{ params: { slug: 'a' } }, { params: { slug: 'b' } }],
+    fallback: false,
+  }
+}
+
+export async function getStaticProps({ params }) {
+  await new Promise((resolve) => setTimeout(resolve, 1000))
+
+  return {
+    props: {
+      params,
+      hello: 'world',
+      post: params.slug,
+      random: Math.random(),
+      time: (await import('perf_hooks')).performance.now(),
+    },
+  }
+}
+
+export default ({ post, time, params }) => {
+  if (useRouter().isFallback) {
+    return <p>hi fallback</p>
+  }
+
+  return (
+    <>
+      <p>Post: {post}</p>
+      <span>time: {time}</span>
+      <div id="params">{JSON.stringify(params)}</div>
+      <div id="query">{JSON.stringify(useRouter().query)}</div>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/blocking-fallback/[slug].js

@@ -0,0 +1,42 @@
+import React from 'react'
+import Link from 'next/link'
+import { useRouter } from 'next/router'
+
+export async function getStaticPaths() {
+  return {
+    paths: [],
+    fallback: false,
+  }
+}
+
+export async function getStaticProps({ params }) {
+  await new Promise((resolve) => setTimeout(resolve, 1000))
+
+  return {
+    props: {
+      params,
+      hello: 'world',
+      post: params.slug,
+      random: Math.random(),
+      time: (await import('perf_hooks')).performance.now(),
+    },
+  }
+}
+
+export default ({ post, time, params }) => {
+  if (useRouter().isFallback) {
+    return <p>hi fallback</p>
+  }
+
+  return (
+    <>
+      <p>Post: {post}</p>
+      <span>time: {time}</span>
+      <div id="params">{JSON.stringify(params)}</div>
+      <div id="query">{JSON.stringify(useRouter().query)}</div>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/blog/[post]/[comment].js

@@ -0,0 +1,40 @@
+import React from 'react'
+import Link from 'next/link'
+
+export async function getStaticPaths() {
+  return {
+    paths: [
+      '/blog/post-1/comment-1',
+      { params: { post: 'post-2', comment: 'comment-2' } },
+    ],
+    fallback: false,
+  }
+}
+
+export async function getStaticProps({ params }) {
+  return {
+    props: {
+      post: params.post,
+      comment: params.comment,
+      time: new Date().getTime(),
+    },
+  }
+}
+
+export default ({ post, comment, time }) => {
+  // we're in a loading state
+  if (!post) {
+    return <p>loading...</p>
+  }
+
+  return (
+    <>
+      <p>Post: {post}</p>
+      <p>Comment: {comment}</p>
+      <span>time: {time}</span>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/blog/[post]/index.js

@@ -0,0 +1,60 @@
+import React from 'react'
+import Link from 'next/link'
+import { useRouter } from 'next/router'
+import 'firebase/firestore'
+
+export async function getStaticPaths() {
+  return {
+    paths: [
+      '/blog/post-1',
+      { params: { post: 'post-2' } },
+      '/blog/[post3]',
+      '/blog/post-4',
+      '/blog/post.1',
+      '/blog/post.1', // handle duplicates
+    ],
+    fallback: false,
+  }
+}
+
+let counter = 0
+
+export async function getStaticProps({ params }) {
+  if (params.post === 'post-10') {
+    await new Promise((resolve) => {
+      setTimeout(() => resolve(), 1000)
+    })
+  }
+
+  if (params.post === 'post-100') {
+    throw new Error('such broken..')
+  }
+
+  if (params.post === 'post-999') {
+    if (++counter < 6) {
+      throw new Error('try again..')
+    }
+  }
+
+  return {
+    props: {
+      params,
+      post: params.post,
+      time: (await import('perf_hooks')).performance.now(),
+    },
+  }
+}
+
+export default ({ post, time, params }) => {
+  return (
+    <>
+      <p>Post: {post}</p>
+      <span>time: {time}</span>
+      <div id="params">{JSON.stringify(params)}</div>
+      <div id="query">{JSON.stringify(useRouter().query)}</div>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/blog/index.js

@@ -0,0 +1,23 @@
+import React from 'react'
+import Link from 'next/link'
+
+export async function getStaticProps() {
+  return {
+    props: {
+      slugs: ['post-1', 'post-2'],
+      time: (await import('perf_hooks')).performance.now(),
+    },
+  }
+}
+
+export default ({ slugs, time }) => {
+  return (
+    <>
+      <p>Posts: {JSON.stringify(slugs)}</p>
+      <span>time: {time}</span>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/catchall-explicit/[...slug].js

@@ -0,0 +1,40 @@
+import Link from 'next/link'
+
+export async function getStaticProps({ params: { slug } }) {
+  if (slug[0] === 'delayby3s') {
+    await new Promise((resolve) => setTimeout(resolve, 3000))
+  }
+
+  return {
+    props: {
+      slug,
+    },
+  }
+}
+
+export async function getStaticPaths() {
+  return {
+    paths: [
+      { params: { slug: ['first'] } },
+      '/catchall-explicit/second',
+      { params: { slug: ['another', 'value'] } },
+      '/catchall-explicit/hello/another',
+      '/catchall-explicit/[first]/[second]',
+      { params: { slug: ['[third]', '[fourth]'] } },
+    ],
+    fallback: false,
+  }
+}
+
+export default function Page({ slug }) {
+  // Important to not check for `slug` existence (testing that build does not
+  // render fallback version and error)
+  return (
+    <>
+      <p id="catchall">Hi {slug.join(' ')}</p>{' '}
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/catchall-optional/[[...slug]].js

@@ -0,0 +1,29 @@
+import Link from 'next/link'
+
+export async function getStaticProps({ params: { slug } }) {
+  return {
+    props: {
+      slug: slug || [],
+    },
+  }
+}
+
+export async function getStaticPaths() {
+  return {
+    paths: [{ params: { slug: [] } }, { params: { slug: ['value'] } }],
+    fallback: false,
+  }
+}
+
+export default ({ slug }) => {
+  // Important to not check for `slug` existence (testing that build does not
+  // render fallback version and error)
+  return (
+    <>
+      <p id="catchall">Catch all: [{slug.join(', ')}]</p>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/catchall/[...slug].js

@@ -0,0 +1,33 @@
+import { useRouter } from 'next/router'
+
+export async function getStaticProps({ params: { slug } }) {
+  if (slug[0] === 'delayby3s') {
+    await new Promise((resolve) => setTimeout(resolve, 3000))
+  }
+
+  return {
+    props: {
+      slug,
+    },
+  }
+}
+
+export async function getStaticPaths() {
+  return {
+    paths: [
+      { params: { slug: ['first'] } },
+      '/catchall/second',
+      { params: { slug: ['another', 'value'] } },
+      '/catchall/hello/another',
+    ],
+    fallback: false,
+  }
+}
+
+export default ({ slug }) => {
+  const { isFallback } = useRouter()
+  if (isFallback) {
+    return <p id="catchall">fallback</p>
+  }
+  return <p id="catchall">Hi {slug.join(' ')}</p>
+}

test/integration/prerender-export/pages/default-revalidate.js

@@ -0,0 +1,24 @@
+import Link from 'next/link'
+
+export async function getStaticProps() {
+  return {
+    props: {
+      world: 'world',
+      time: new Date().getTime(),
+    },
+  }
+}
+
+export default ({ world, time }) => (
+  <>
+    <p>hello {world}</p>
+    <span>time: {time}</span>
+    <Link href="/" id="home">
+      to home
+    </Link>
+    <br />
+    <Link href="/something" id="something">
+      to something
+    </Link>
+  </>
+)

test/integration/prerender-export/pages/dynamic/[slug].js

@@ -0,0 +1,27 @@
+import Link from 'next/link'
+
+export async function getStaticProps({ params: { slug } }) {
+  return {
+    props: { slug },
+  }
+}
+
+export async function getStaticPaths() {
+  return {
+    paths: [{ params: { slug: '[first]' } }, '/dynamic/[second]'],
+    fallback: false,
+  }
+}
+
+export default ({ slug }) => {
+  // Important to not check for `slug` existence (testing that build does not
+  // render fallback version and error)
+  return (
+    <>
+      <p id="param">Hi {slug}!</p>{' '}
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/fallback-only/[slug].js

@@ -0,0 +1,42 @@
+import React from 'react'
+import Link from 'next/link'
+import { useRouter } from 'next/router'
+
+export async function getStaticPaths() {
+  return {
+    paths: [],
+    fallback: false,
+  }
+}
+
+export async function getStaticProps({ params }) {
+  await new Promise((resolve) => setTimeout(resolve, 1000))
+
+  return {
+    props: {
+      params,
+      hello: 'world',
+      post: params.slug,
+      random: Math.random(),
+      time: (await import('perf_hooks')).performance.now(),
+    },
+  }
+}
+
+export default ({ post, time, params }) => {
+  if (useRouter().isFallback) {
+    return <p>hi fallback</p>
+  }
+
+  return (
+    <>
+      <p>Post: {post}</p>
+      <span>time: {time}</span>
+      <div id="params">{JSON.stringify(params)}</div>
+      <div id="query">{JSON.stringify(useRouter().query)}</div>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/index.js

@@ -0,0 +1,106 @@
+import Link from 'next/link'
+
+export async function getStaticProps() {
+  // throw new Error('oops from getStaticProps')
+  return {
+    props: { world: 'world', time: new Date().getTime() },
+  }
+}
+
+const Page = ({ world, time }) => {
+  return (
+    <>
+      {/* <div id='after-change'>idk</div> */}
+      <p>hello {world}</p>
+      <span>time: {time}</span>
+      <Link href="/non-json/[p]" as="/non-json/1" id="non-json">
+        to non-json
+      </Link>
+      <br />
+      <Link href="/another?hello=world" as="/another/?hello=world" id="another">
+        to another
+      </Link>
+      <br />
+      <Link href="/something" id="something">
+        to something
+      </Link>
+      <br />
+      <Link href="/normal" id="normal">
+        to normal
+      </Link>
+      <br />
+      <Link href="/blog/[post]" as="/blog/post-1" id="post-1">
+        to dynamic
+      </Link>
+      <Link href="/blog/[post]" as="/blog/post-100" id="broken-post">
+        to broken
+      </Link>
+      <Link
+        href="/blog/[post]"
+        as="/blog/post-999"
+        prefetch={false}
+        id="broken-at-first-post"
+      >
+        to broken at first
+      </Link>
+      <br />
+      <Link
+        href="/blog/[post]/[comment]"
+        as="/blog/post-1/comment-1"
+        id="comment-1"
+      >
+        to another dynamic
+      </Link>
+      <Link href="/catchall/[...slug]" as="/catchall/first" id="to-catchall">
+        to catchall
+      </Link>
+      <br />
+      <Link href="/index" id="to-nested-index">
+        to nested index
+      </Link>
+      <br />
+      <Link href="/lang/[lang]/about?lang=en" as="/about" id="to-rewritten-ssg">
+        to rewritten static path page
+      </Link>
+      <br />
+      <Link
+        href="/catchall-optional/[[...slug]]"
+        as="/catchall-optional"
+        id="catchall-optional-root"
+      >
+        to optional catchall root
+      </Link>
+      <Link
+        href="/catchall-optional/[[...slug]]"
+        as="/catchall-optional/value"
+        id="catchall-optional-value"
+      >
+        to optional catchall page /value
+      </Link>
+      <br />
+      <Link href="/dynamic/[slug]" as="/dynamic/[first]" id="dynamic-first">
+        to dynamic [first] page
+      </Link>
+      <Link href="/dynamic/[slug]" as="/dynamic/[second]" id="dynamic-second">
+        to dynamic [second] page
+      </Link>
+      <br />
+      <Link
+        href="/catchall-explicit/[...slug]"
+        as="/catchall-explicit/[first]/[second]"
+        id="catchall-explicit-string"
+      >
+        to catchall-explicit [first]/[second] page
+      </Link>
+      <Link
+        href="/catchall-explicit/[...slug]"
+        as="/catchall-explicit/[third]/[fourth]"
+        id="catchall-explicit-object"
+      >
+        to catchall-explicit [third]/[fourth] page
+      </Link>
+    </>
+  )
+}
+
+export default Page

test/integration/prerender-export/pages/index/index.js

@@ -0,0 +1,18 @@
+import Link from 'next/link'
+
+export async function getStaticProps() {
+  return {
+    props: { world: 'nested index' },
+  }
+}
+
+export default ({ world }) => {
+  return (
+    <>
+      <p>hello {world}</p>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/lang/[lang]/about.js

@@ -0,0 +1,12 @@
+export default ({ lang }) => <p id="about">About: {lang}</p>
+
+export const getStaticProps = ({ params: { lang } }) => ({
+  props: {
+    lang,
+  },
+})
+
+export const getStaticPaths = () => ({
+  paths: ['en', 'es', 'fr', 'de'].map((p) => `/lang/${p}/about`),
+  fallback: false,
+})

test/integration/prerender-export/pages/non-json-blocking/[p].js

@@ -0,0 +1,21 @@
+import { useRouter } from 'next/router'
+
+export async function getStaticProps() {
+  return {
+    props: { time: new Date() },
+  }
+}
+
+export async function getStaticPaths() {
+  return { paths: [], fallback: false }
+}
+
+const Page = ({ time }) => {
+  const { isFallback } = useRouter()
+
+  if (isFallback) return null
+
+  return <p>hello blocking {time.toString()}</p>
+}
+
+export default Page

test/integration/prerender-export/pages/non-json/[p].js

@@ -0,0 +1,21 @@
+import { useRouter } from 'next/router'
+
+export async function getStaticProps() {
+  return {
+    props: { time: new Date() },
+  }
+}
+
+export async function getStaticPaths() {
+  return { paths: [], fallback: false }
+}
+
+const Page = ({ time }) => {
+  const { isFallback } = useRouter()
+
+  if (isFallback) return null
+
+  return <p>hello {time.toString()}</p>
+}
+
+export default Page

test/integration/prerender-export/pages/normal.js

@@ -0,0 +1 @@
+export default () => <p id="normal-text">a normal page</p>

test/integration/prerender-export/pages/something.js

@@ -0,0 +1,33 @@
+import React from 'react'
+import Link from 'next/link'
+import { useRouter } from 'next/router'
+
+export async function getStaticProps({ params }) {
+  return {
+    props: {
+      world: 'world',
+      params: params || {},
+      time: new Date().getTime(),
+      random: Math.random(),
+    },
+  }
+}
+
+export default ({ world, time, params, random }) => {
+  return (
+    <>
+      <p>hello: {world}</p>
+      <span>time: {time}</span>
+      <div id="random">{random}</div>
+      <div id="params">{JSON.stringify(params)}</div>
+      <div id="query">{JSON.stringify(useRouter().query)}</div>
+      <Link href="/" id="home">
+        to home
+      </Link>
+      <br />
+      <Link href="/another" id="another">
+        to another
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/pages/user/[user]/profile.js

@@ -0,0 +1,27 @@
+import React from 'react'
+import Link from 'next/link'
+
+export async function getStaticPaths() {
+  return { paths: [], fallback: false }
+}
+
+export async function getStaticProps({ params }) {
+  return {
+    props: {
+      user: params.user,
+      time: (await import('perf_hooks')).performance.now(),
+    },
+  }
+}
+
+export default ({ user, time }) => {
+  return (
+    <>
+      <p>User: {user}</p>
+      <span>time: {time}</span>
+      <Link href="/" id="home">
+        to home
+      </Link>
+    </>
+  )
+}

test/integration/prerender-export/test/index.test.ts

@@ -0,0 +1,246 @@
+/* eslint-env jest */
+import fs from 'fs-extra'
+import { join } from 'path'
+import webdriver from 'next-webdriver'
+import {
+  nextBuild,
+  renderViaHTTP,
+  startStaticServer,
+  stopApp,
+  waitFor,
+} from 'next-test-utils'
+
+const appDir = join(__dirname, '..')
+let exportDir = join(appDir, 'out')
+let app
+let appPort
+let buildId
+
+const navigateTest = (dev = false) => {
+  it('should navigate between pages successfully', async () => {
+    const toBuild = [
+      '/',
+      '/another',
+      '/something',
+      '/normal',
+      '/blog/post-1',
+      '/blog/post-1/comment-1',
+      '/catchall/first',
+    ]
+
+    await waitFor(2500)
+
+    await Promise.all(toBuild.map((pg) => renderViaHTTP(appPort, pg)))
+
+    const browser = await webdriver(appPort, '/')
+    let text = await browser.elementByCss('p').text()
+    expect(text).toMatch(/hello.*?world/)
+
+    // go to /another
+    async function goFromHomeToAnother() {
+      await browser.eval('window.beforeAnother = true')
+      await browser.elementByCss('#another').click()
+      await browser.waitForElementByCss('#home')
+      text = await browser.elementByCss('p').text()
+      expect(await browser.eval('window.beforeAnother')).toBe(true)
+      expect(text).toMatch(/hello.*?world/)
+    }
+    await goFromHomeToAnother()
+
+    // go to /
+    async function goFromAnotherToHome() {
+      await browser.eval('window.didTransition = 1')
+      await browser.elementByCss('#home').click()
+      await browser.waitForElementByCss('#another')
+      text = await browser.elementByCss('p').text()
+      expect(text).toMatch(/hello.*?world/)
+      expect(await browser.eval('window.didTransition')).toBe(1)
+    }
+    await goFromAnotherToHome()
+
+    // Client-side SSG data caching test
+    {
+      // Let revalidation period lapse
+      await waitFor(2000)
+
+      // Trigger revalidation (visit page)
+      await goFromHomeToAnother()
+      const snapTime = await browser.elementByCss('#anotherTime').text()
+
+      // Wait for revalidation to finish
+      await waitFor(2000)
+
+      // Re-visit page
+      await goFromAnotherToHome()
+      await goFromHomeToAnother()
+
+      const nextTime = await browser.elementByCss('#anotherTime').text()
+      if (dev) {
+        expect(snapTime).not.toMatch(nextTime)
+      } else {
+        expect(snapTime).toMatch(nextTime)
+      }
+
+      // Reset to Home for next test
+      await goFromAnotherToHome()
+    }
+
+    // go to /something
+    await browser.elementByCss('#something').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('p').text()
+    expect(text).toMatch(/hello.*?world/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#post-1')
+
+    // go to /blog/post-1
+    await browser.elementByCss('#post-1').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('p').text()
+    expect(text).toMatch(/Post:.*?post-1/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /index
+    await browser.elementByCss('#to-nested-index').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('p').text()
+    expect(text).toMatch(/hello nested index/)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /catchall-optional
+    await browser.elementByCss('#catchall-optional-root').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('p').text()
+    expect(text).toMatch(/Catch all: \[\]/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /dynamic/[first]
+    await browser.elementByCss('#dynamic-first').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('#param').text()
+    expect(text).toMatch(/Hi \[first\]!/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /dynamic/[second]
+    await browser.elementByCss('#dynamic-second').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('#param').text()
+    expect(text).toMatch(/Hi \[second\]!/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /catchall-explicit/[first]/[second]
+    await browser.elementByCss('#catchall-explicit-string').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('#catchall').text()
+    expect(text).toMatch(/Hi \[first\] \[second\]/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /catchall-explicit/[first]/[second]
+    await browser.elementByCss('#catchall-explicit-object').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('#catchall').text()
+    expect(text).toMatch(/Hi \[third\] \[fourth\]/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /catchall-optional/value
+    await browser.elementByCss('#catchall-optional-value').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('p').text()
+    expect(text).toMatch(/Catch all: \[value\]/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#comment-1')
+
+    // go to /blog/post-1/comment-1
+    await browser.elementByCss('#comment-1').click()
+    await browser.waitForElementByCss('#home')
+    text = await browser.elementByCss('p:nth-child(2)').text()
+    expect(text).toMatch(/Comment:.*?comment-1/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    // go to /catchall/first
+    await browser.elementByCss('#home').click()
+    await browser.waitForElementByCss('#to-catchall')
+    await browser.elementByCss('#to-catchall').click()
+    await browser.waitForElementByCss('#catchall')
+    text = await browser.elementByCss('#catchall').text()
+    expect(text).toMatch(/Hi.*?first/)
+    expect(await browser.eval('window.didTransition')).toBe(1)
+
+    await browser.close()
+  })
+}
+
+describe('SSG Prerender export', () => {
+  ;(process.env.TURBOPACK_DEV ? describe.skip : describe)(
+    'production mode',
+    () => {
+      describe('export mode', () => {
+        beforeAll(async () => {
+          await fs.remove(join(appDir, '.next'))
+          await fs.remove(exportDir)
+          await nextBuild(appDir, undefined, { cwd: appDir })
+          app = await startStaticServer(exportDir)
+          appPort = app.address().port
+          buildId = await fs.readFile(join(appDir, '.next/BUILD_ID'), 'utf8')
+        })
+
+        afterAll(async () => {
+          if (app) {
+            await stopApp(app)
+          }
+        })
+
+        it('should copy prerender files and honor exportTrailingSlash', async () => {
+          const routes = [
+            '/another',
+            '/something',
+            '/blog/post-1',
+            '/blog/post-2/comment-2',
+          ]
+
+          for (const route of routes) {
+            await fs.access(join(exportDir, `${route}/index.html`))
+            await fs.access(
+              join(exportDir, '_next/data', buildId, `${route}.json`)
+            )
+          }
+        })
+
+        navigateTest()
+      })
+    }
+  )
+})

test/integration/prerender-export/world.txt

@@ -0,0 +1 @@
+world