fs: preserve exact nanoseconds in CopyUtimes on POSIX

src/node_file.cc

@@ -56,6 +56,8 @@
 #ifdef _WIN32
 #include <windows.h>
 #else
+#include <fcntl.h>
+#include <sys/stat.h>
 #include <unistd.h>
 #endif
 
@@ -4830,10 +4832,22 @@ CpError CopyUtimes(const std::filesystem::path& src,
   }
 
   const uv_stat_t* const s = static_cast<const uv_stat_t*>(req.ptr);
+  auto dest_file_path_str = ConvertPathToUTF8(dest);
+
+#ifdef __POSIX__
+  struct timespec ts[2];
+  ts[0].tv_sec = s->st_atim.tv_sec;
+  ts[0].tv_nsec = s->st_atim.tv_nsec;
+  ts[1].tv_sec = s->st_mtim.tv_sec;
+  ts[1].tv_nsec = s->st_mtim.tv_nsec;
+  if (utimensat(AT_FDCWD, dest_file_path_str.c_str(), ts, 0) != 0) {
+    return CpError::Uv(
+        uv_translate_sys_error(errno), "utime", dest_file_path_str);
+  }
+#else
   const double source_atime = s->st_atim.tv_sec + s->st_atim.tv_nsec / 1e9;
   const double source_mtime = s->st_mtim.tv_sec + s->st_mtim.tv_nsec / 1e9;
 
-  auto dest_file_path_str = ConvertPathToUTF8(dest);
   int utime_result = uv_fs_utime(nullptr,
                                  &req,
                                  dest_file_path_str.c_str(),
@@ -4843,6 +4857,7 @@ CpError CopyUtimes(const std::filesystem::path& src,
   if (is_uv_error(utime_result)) {
     return CpError::Uv(utime_result, "utime", dest_file_path_str);
   }
+#endif
   return {};
 }
 

test/parallel/test-fs-cp-sync-preserve-timestamps-nanoseconds.mjs

@@ -0,0 +1,53 @@
+// This tests that cpSync with preserveTimestamps preserves exact nanosecond
+// timestamps on POSIX when copying directories or overwriting files.
+import * as common from '../common/index.mjs';
+import { nextdir } from '../common/fs.js';
+import tmpdir from '../common/tmpdir.js';
+import assert from 'node:assert';
+import { cpSync, mkdirSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+if (common.isWindows) {
+  common.skip('Nanosecond timestamp preservation via utimensat is POSIX-only');
+}
+
+tmpdir.refresh();
+
+// 1. Recursive directory copy (exercises CopyDirRecursive -> CopyUtimes in C++)
+const srcDir = nextdir();
+mkdirSync(srcDir, { recursive: true });
+const srcFile = join(srcDir, 'file.txt');
+writeFileSync(srcFile, 'hello');
+
+const srcFileStat = statSync(srcFile, { bigint: true });
+const srcDirStat = statSync(srcDir, { bigint: true });
+
+const destDir = nextdir();
+cpSync(srcDir, destDir, {
+  recursive: true,
+  preserveTimestamps: true,
+});
+
+const destFile = join(destDir, 'file.txt');
+const destFileStat = statSync(destFile, { bigint: true });
+const destDirStat = statSync(destDir, { bigint: true });
+
+assert.strictEqual(destFileStat.mtimeNs, srcFileStat.mtimeNs);
+assert.strictEqual(destFileStat.mtime.getTime(), srcFileStat.mtime.getTime());
+assert.strictEqual(destDirStat.mtimeNs, srcDirStat.mtimeNs);
+assert.strictEqual(destDirStat.mtime.getTime(), srcDirStat.mtime.getTime());
+
+// 2. Single-file overwrite with force: true (exercises CpSyncOverrideFile -> CopyUtimes in C++)
+const singleDest = join(nextdir(), 'existing.txt');
+mkdirSync(join(singleDest, '..'), { recursive: true });
+writeFileSync(singleDest, 'old');
+
+const updatedSrcFileStat = statSync(srcFile, { bigint: true });
+cpSync(srcFile, singleDest, {
+  force: true,
+  preserveTimestamps: true,
+});
+
+const singleDestStat = statSync(singleDest, { bigint: true });
+assert.strictEqual(singleDestStat.mtimeNs, updatedSrcFileStat.mtimeNs);
+assert.strictEqual(singleDestStat.mtime.getTime(), updatedSrcFileStat.mtime.getTime());