Next.js v13.5.5 でビルドが失敗する件

Error: File /home/snaka/projects/hoge-fuga/dist/src/.next/server/pages/xxxx/edit.js does not exist.
    at Job.emitDependency (/home/snaka/projects/hoge-fuga/node_modules/next/dist/compiled/@vercel/nft/index.js:1:39473)
    at async Promise.all (index 30)
    at async nodeFileTrace (/home/snaka/projects/hoge-fuga/node_modules/next/dist/compiled/@vercel/nft/index.js:1:35430)
    at async /home/snaka/projects/hoge-fuga/node_modules/next/dist/build/collect-build-traces.js:260:28
    at async Span.traceAsyncFn (/home/snaka/projects/hoge-fuga/node_modules/next/dist/trace/trace.js:105:20)
    at async collectBuildTraces (/home/snaka/projects/hoge-fuga/node_modules/next/dist/build/collect-build-traces.js:131:5)

        const result = await nodeFileTrace(chunksToTrace, {
          base: outputFileTracingRoot,
          processCwd: dir,
          mixedModules: true,
          async readFile(p) {
            try {
              return await fs.readFile(p, 'utf8')
            } catch (e) {
              if (isError(e) && (e.code === 'ENOENT' || e.code === 'EISDIR')) {
                // handle temporary internal webpack files
                if (p.match(/static[/\\]media/)) {
                  return ''
                }
                return null
              }
              throw e
            }
          },

    "@vercel/nft": "0.22.6",

export async function nodeFileTrace(files: string[], opts: NodeFileTraceOptions = {}): Promise<NodeFileTraceResult> {
  const job = new Job(opts);

  if (opts.readFile)
    job.readFile = opts.readFile
  if (opts.stat)
    job.stat = opts.stat
  if (opts.readlink)
    job.readlink = opts.readlink
  if (opts.resolve)
    job.resolve = opts.resolve

  job.ts = true;

  await Promise.all(files.map(async file => {
    const path = resolve(file);
    await job.emitFile(path, 'initial');
    return job.emitDependency(path);
  }));

  const result: NodeFileTraceResult = {
    fileList: job.fileList,
    esmFileList: job.esmFileList,
    reasons: job.reasons,
    warnings: job.warnings
  };
  return result;
};

    const cachedAnalysis = this.analysisCache.get(path);
    if (cachedAnalysis) {
      analyzeResult = cachedAnalysis;
    }
    else {
      const source = await this.readFile(path);
      if (source === null) throw new Error('File ' + path + ' does not exist.');
      // analyze should not have any side-effects e.g. calling `job.emitFile`
      // directly as this will not be included in the cachedAnalysis and won't
      // be emit for successive runs that leverage the cache
      analyzeResult = await analyze(path, source.toString(), this);
      this.analysisCache.set(path, analyzeResult);
    }

  async emitDependency (path: string, parent?: string) {

  await Promise.all(files.map(async file => {
    const path = resolve(file);
    await job.emitFile(path, 'initial');
    return job.emitDependency(path);
  }));

export async function nodeFileTrace(files: string[], opts: NodeFileTraceOptions = {}): Promise<NodeFileTraceResult> {

        const chunksToTrace: string[] = [
          ...(buildTraceContext?.chunksTrace?.action.input || []),
          ...serverEntries,
          ...minimalServerEntries,
        ]

      const serverEntries = [
        ...sharedEntriesSet,
        ...(isStandalone
          ? [
              require.resolve('next/dist/server/lib/start-server'),
              require.resolve('next/dist/server/next'),
              require.resolve('next/dist/server/require-hook'),
            ]
          : []),
        require.resolve('next/dist/server/next-server'),
      ].filter(Boolean) as string[]

      const minimalServerEntries = [
        ...sharedEntriesSet,
        require.resolve('next/dist/compiled/next-server/server.runtime.prod'),
      ].filter(Boolean)

      const sharedEntriesSet = [
        ...(config.experimental.turbotrace
          ? []
          : Object.keys(defaultOverrides).map((value) =>
              require.resolve(value, {
                paths: [require.resolve('next/dist/server/require-hook')],
              })
            )),
        require.resolve('next/dist/compiled/next-server/app-page.runtime.prod'),
        require.resolve(
          'next/dist/compiled/next-server/app-route.runtime.prod'
        ),
        require.resolve('next/dist/compiled/next-server/pages.runtime.prod'),
        require.resolve(
          'next/dist/compiled/next-server/pages-api.runtime.prod'
        ),
      ]

export async function collectBuildTraces({
  dir,
  config,
  distDir,
  pageKeys,
  pageInfos,
  staticPages,
  nextBuildSpan = new Span({ name: 'build' }),
  hasSsrAmpPages,
  buildTraceContext,
  outputFileTracingRoot,
}: {

            const buildTraceWorker = new Worker(
              require.resolve('./collect-build-traces'),
              {
                numWorkers: 1,
                exposedMethods: ['collectBuildTraces'],
              }
            ) as Worker & typeof import('./collect-build-traces')


            buildTracesPromise = buildTraceWorker
              .collectBuildTraces({
                dir,
                config,
                distDir,
                pageKeys,
                pageInfos: [],
                staticPages: [],
                hasSsrAmpPages: false,
                buildTraceContext,
                outputFileTracingRoot,
              })
              .catch((err) => {
                console.error(err)
                process.exit(1)
              })

          await webpackBuild(['server']).then((res) => {
            buildTraceContext = res.buildTraceContext
            durationInSeconds += res.duration
            const buildTraceWorker = new Worker(
              require.resolve('./collect-build-traces'),
              {
                numWorkers: 1,
                exposedMethods: ['collectBuildTraces'],
              }
            ) as Worker & typeof import('./collect-build-traces')


            buildTracesPromise = buildTraceWorker
              .collectBuildTraces({
                dir,
                config,
                distDir,
                pageKeys,
                pageInfos: [],
                staticPages: [],
                hasSsrAmpPages: false,
                buildTraceContext,
                outputFileTracingRoot,
              })
              .catch((err) => {
                console.error(err)
                process.exit(1)
              })
          })

export async function webpackBuild(
  compilerNames?: typeof ORDERED_COMPILER_NAMES
) {
  const config = NextBuildContext.config!


  if (config.experimental.webpackBuildWorker) {
    debug('using separate compiler workers')
    return await webpackBuildWithWorker(compilerNames)
  } else {
    debug('building all compilers in same process')
    const webpackBuildImpl = require('./impl').webpackBuildImpl
    return await webpackBuildImpl()
  }
}

    args['--debug'] || process.env.NEXT_DEBUG_BUILD,

        cpus: z.number().optional(),

DEBUG=* yarn next build --debug

   Linting and checking validity of types  ...
 ⚠ The Next.js plugin was not detected in your ESLint configuration. See https://nextjs.org/docs/basic-features/eslint#migrating-existing-config
 ✓ Linting and checking validity of types    
   Creating an optimized production build  .  
next:build:webpack-build using separate compiler workers +0ms
   Creating an optimized production build  ...
2023-10-21T14:43:29.919Z next:build:webpack-build starting compiler server
2023-10-21T14:43:29.919Z next:build:webpack-build starting server compiler
   Creating an optimized production build  ..
2023-10-21T14:43:32.675Z next:build:webpack-build server compiler finished 2756ms
   Creating an optimized production build  .
2023-10-21T14:43:33.144Z next:build:webpack-build starting compiler edge-server
2023-10-21T14:43:33.145Z next:build:webpack-build starting edge-server compiler
2023-10-21T14:43:33.196Z next:build:webpack-build edge-server compiler finished 51ms
   Creating an optimized production build  ...
2023-10-21T14:43:33.643Z next:build:webpack-build starting compiler client
2023-10-21T14:43:33.643Z next:build:webpack-build starting client compiler
   Creating an optimized production build  ..
2023-10-21T14:43:35.197Z next:build:webpack-build client compiler finished 1554ms
 ✓ Creating an optimized production build    
 ✓ Compiled successfully
 ✓ Collecting page data    
next:build:build-traces starting build traces +0ms
 ✓ Generating static pages (38/38) 

   Linting and checking validity of types  ...
 ⚠ The Next.js plugin was not detected in your ESLint configuration. See https://nextjs.org/docs/basic-features/eslint#migrating-existing-config
 ✓ Linting and checking validity of types    
   Creating an optimized production build  .  
  next:build:webpack-build building all compilers in same process +0ms
  next:build:webpack-build starting compiler undefined +0ms
  next:build:webpack-build starting server compiler +0ms
   Creating an optimized production build  ..  
  next:build:webpack-build server compiler finished 5162ms +5s
  next:build:webpack-build starting edge-server compiler +0ms
  next:build:webpack-build edge-server compiler finished 9ms +9ms
  next:build:webpack-build starting client compiler +0ms
   Creating an optimized production build  ...  
  next:build:webpack-build client compiler finished 6476ms +6s
 ✓ Creating an optimized production build    
 ✓ Compiled successfully
 ✓ Collecting page data    
  next:build:build-traces starting build traces +0ms
 ✓ Generating static pages (38/38) 

export async function webpackBuildImpl(
  compilerName?: keyof typeof COMPILER_INDEXES
): Promise<{

      buildTraceContext: traceEntryPointsPlugin?.buildTraceContext,

  const traceEntryPointsPlugin = (
    serverConfig as webpack.Configuration
  ).plugins?.find(isTraceEntryPointsPlugin)

  const serverConfig = configs[1]

        getBaseWebpackConfig(dir, {
          ...commonWebpackOptions,
          runWebpackSpan,
          middlewareMatchers: entrypoints.middlewareMatchers,
          compilerType: COMPILER_NAMES.server,
          entrypoints: entrypoints.server,
          ...info,
        }),

export default async function getBaseWebpackConfig(

  const isNodeServer = compilerType === COMPILER_NAMES.server

  // If the current compilation is aimed at server-side code instead of client-side code.
  const isNodeOrEdgeCompilation = isNodeServer || isEdgeServer

      config.outputFileTracing &&
        isNodeServer &&
        !dev &&
        new (require('./webpack/plugins/next-trace-entrypoints-plugin')
          .TraceEntryPointsPlugin as typeof import('./webpack/plugins/next-trace-entrypoints-plugin').TraceEntryPointsPlugin)(
          {
            rootDir: dir,
            appDir: appDir,
            pagesDir: pagesDir,
            esmExternals: config.experimental.esmExternals,
            outputFileTracingRoot: config.experimental.outputFileTracingRoot,
            appDirEnabled: hasAppDir,
            turbotrace: config.experimental.turbotrace,
            traceIgnores: config.experimental.outputFileTracingIgnores || [],
          }
        ),

export class TraceEntryPointsPlugin implements webpack.WebpackPluginInstance {
  public buildTraceContext: BuildTraceContext = {}

      this.buildTraceContext.chunksTrace = {
        action: {
          action: 'annotate',
          input: [...chunksToTrace],

      for (const entrypoint of compilation.entrypoints.values()) {
        const entryFiles = new Set<string>()

        for (const chunk of entrypoint
          .getEntrypointChunk()
          .getAllReferencedChunks()) {
          for (const file of chunk.files) {
            if (isTraceable(file)) {
              const filePath = nodePath.join(outputPath, file)
              chunksToTrace.add(filePath)
              entryFiles.add(filePath)
            }
          }
          for (const file of chunk.auxiliaryFiles) {
            if (isTraceable(file)) {
              const filePath = nodePath.join(outputPath, file)
              chunksToTrace.add(filePath)
              entryFiles.add(filePath)
            }
          }
        }
        entryFilesMap.set(entrypoint, entryFiles)
        entryNameFilesMap.set(entrypoint.name, [...entryFiles])
      }

    outputFileTracing: z.boolean().optional(),

export default async function build(
  dir: string,
  reactProductionProfiling = false,
  debugOutput = false,
  runLint = true,
  noMangling = false,
  appDirOnly = false,
  turboNextBuild = false,
  turboNextBuildRoot = null,
  buildMode: 'default' | 'experimental-compile' | 'experimental-generate'
): Promise<void> {
  const isCompile = buildMode === 'experimental-compile'
  const isGenerate = buildMode === 'experimental-generate'

  if (args['--experimental-turbo']) {
    process.env.TURBOPACK = '1'
  }

  return build(
    dir,
    args['--profile'],
    args['--debug'] || process.env.NEXT_DEBUG_BUILD,
    !args['--no-lint'],
    args['--no-mangling'],
    args['--experimental-app-only'],
    !!process.env.TURBOPACK,
    args['--experimental-turbo-root'],
    args['--build-mode'] || 'default'
  ).catch((err) => {

  reactProductionProfiling = false,
  debugOutput = false,
  runLint = true,
  noMangling = false,
  appDirOnly = false,
  turboNextBuild = false,
  turboNextBuildRoot = null,
  buildMode: 'default' 

          const { duration: webpackBuildDuration, ...rest } = turboNextBuild
            ? await turbopackBuild()
            : await webpackBuild()

          buildTraceContext = rest.buildTraceContext

├── index.js
├── index.js.nft.json

├── index.html
├── index.js.nft.json