nextjs - 💡(How to fix) Fix Turbopack file tracing includes repository root: can’t access reasons during real build [15 comments, 3 participants]

{
  "version": 1,
  "files": [
    "../../../../../../Makefile",
    "../../../../../../README.md",
    "../../../../../../components.json",
    "...",
    "../../../../chunks/ssr/src_messages_fr_json_3c6a9a9a._.js",
    "./page/react-loadable-manifest.json",
    "./page_client-reference-manifest.js"
  ]
}

---

Operating System:
  Platform: win32
  Arch: x64
  Version: Windows 11 Pro
  Available memory (MB): 16093
  Available CPU cores: 16
Binaries:
  Node: 22.20.0
  npm: 11.6.2
  Yarn: N/A
  pnpm: N/A
Relevant Packages:
  next: 15.5.5 // Latest available version is detected (15.5.5).
  eslint-config-next: 15.5.5
  react: 19.2.0
  react-dom: 19.2.0
  typescript: 5.9.3
Next.js Config:
  output: N/A

---

#!/usr/bin/env node
import { nodeFileTrace } from '@vercel/nft';
import path from 'path';
import { fileURLToPath } from 'url';

const __dirname = path.dirname(fileURLToPath(import.meta.url));

function printStack(file, reasons, stdout, cwd, depth = 0) {
  const indent = '  '.repeat(depth);
  stdout.push(`${indent}${file}`);

  const reason = reasons.get(file);

  if (
    !reason ||
    !reason.parents ||
    (reason.type.length === 1 &&
      reason.type.includes('initial') &&
      reason.parents.size === 0)
  ) {
    return;
  }

  // Show why this file was included
  const types = Array.from(reason.type).join(', ');
  stdout.push(`${indent}  └─ Reason: ${types}`);

  for (let parent of reason.parents) {
    printStack(parent, reasons, stdout, cwd, depth + 1);
  }
}

async function main() {
  const files = [
    path.join(__dirname, '.next/server/app/[locale]/PATH_TO_MY_PAGE/page.js'),
  ];

  console.log(`Tracing files:\n${files.join('\n')}\n`);

  try {
    const { fileList, reasons } = await nodeFileTrace(files, {
      base: process.cwd(),
      processCwd: process.cwd(),
      mixedModules: true,
      conditions: ['node', 'import', 'require', 'default', 'module', 'production'],
      ignore: [
        '**/*.map',
        '**/node_modules/.bin/**',
        '**/.next/cache/**',
        '**/next/dist/**',
      ],
      exportsOnly: true,
    });

    console.log('Traced files with dependency chains:');
    console.log('=====================================\n');

    for (const file of fileList) {
      console.log(`📁 ${file}`);
      const stack = [];
      printStack(file, reasons, stack, process.cwd());

      // Remove the first line since we already printed the file name
      stack.shift();

      if (stack.length > 0) {
        console.log('Dependencies:');
        console.log(stack.join('\n'));
      } else {
        console.log('  └─ Entry point (no dependencies)');
      }
      console.log('');
    }

    console.log(`Total: ${fileList.size} files`);
  } catch (err) {
    console.error('Error while tracing files:', err);
    process.exit(1);
  }
}

main();

---

const s = {
  fileList: r.fileList,
  esmFileList: r.esmFileList,
  reasons: r.reasons,
  warnings: r.warnings,
};

const path = (() => {
  try { return require('path'); } catch (_) { return eval('require')('path'); }
})();

let fs;
try {
  // Prefer normal require when available
  if (typeof require === 'function') {
    fs = require('fs');
  } else {
    // Fallback to eval('require') which avoids static analysis by bundlers
    fs = eval('require')('fs');
  }
} catch (err) {
  // Last-ditch async fallback if running in ESM async context
  try {
    // This requires the surrounding function to be async. Use only if safe.
    // const mod = await import('fs'); fs = mod.default || mod;
    fs = null;
  } catch (e) {
    fs = null;
  }
}

try {
  const out = []; // build your 'out' array earlier as before
  for (const file of r.fileList) {
    const reason = r.reasons.get(file);
    const types = reason ? Array.from(reason.type).join(', ') : '(no reason)';
    const parents = reason && reason.parents ? Array.from(reason.parents) : [];
    out.push({ file, types, parents });
  }

  if (fs) {
    const outFile = path.join(process.cwd(), '.next', 'nft-debug.json');
    // ensure dir exists
    try { fs.mkdirSync(path.dirname(outFile), { recursive: true }); } catch (_) {}
    fs.writeFileSync(outFile, JSON.stringify(out, null, 2));
    console.log('NFT debug written to:', outFile);
  } else {
    // If fs is not available, emit a small signal to the console with summary info
    // Avoid printing the entire trace to stdout to prevent blocking
    console.error('fs not available in this context. First 20 traced files:');
    console.error(out.slice(0, 20).map(o => `${o.file} -> ${o.types}`).join('\n'));
  }
} catch (e) {
  try { console.error('Failed to write nft debug:', e && e.stack ? e.stack : String(e)); } catch (_) {}
}
  return s;
}