test(startup): record the server's modules on Node before 22.15 too

test-startup-imports.js and the repro test-startup-heavy-imports.js failed
at client.connect ("Connection closed") on every Node before 22.15.0:
checked on 18.20.8, 20.19.5, 20.20.2 and 22.14.0.

Their preload imported registerHooks from node:module, which Node has only
from 22.15.0 / 23.5.0. On older Node the preload failed to link ("does not
provide an export named 'registerHooks'") and the server never started. The
preload now uses registerHooks() where it exists. Before 22.15 it records
imports through module.register() (record-modules-hooks.mjs) and requires
through Module._resolveFilename, in the same log format.

At the commit before, the test fails at connect on 20.20.2 and 22.14.0. Here
it passes on 18.20.8, 20.20.2, 22.14.0, 22.15.0 and 24.18.0, with the same
374 modules recorded before initialize on each.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: mihailt

test/fixtures/record-modules-hooks.mjs

@@ -0,0 +1,12 @@
+// Registered by record-modules-preload.mjs with module.register() on Node
+// before 22.15. Runs on Node's loader thread and writes every module an import
+// resolves to DC_TEST_MODULE_LOG, in the preload's format.
+import fs from 'node:fs';
+
+const log = fs.openSync(process.env.DC_TEST_MODULE_LOG, 'a');
+
+export async function resolve(specifier, context, nextResolve) {
+  const resolved = await nextResolve(specifier, context);
+  fs.writeSync(log, `${Date.now()} ${resolved.url} ${context.parentURL ?? ''}\n`);
+  return resolved;
+}

test/fixtures/record-modules-preload.mjs

@@ -1,15 +1,32 @@
 // Preloaded into the real server (node --import) by test/helpers/server-modules.js:
 // writes every module the server resolves, through import or require, to
 // DC_TEST_MODULE_LOG as it happens, one "<Date.now()> <url> <parent url>" line each.
+// module.registerHooks() sees both, but Node has it only from 22.15. Before
+// that, imports are recorded by record-modules-hooks.mjs through
+// module.register(), and requires through Module._resolveFilename (which a
+// require('node:...') of a built-in skips; the tests leave built-ins out).
 import fs from 'node:fs';
-import { registerHooks } from 'node:module';
+import Module from 'node:module';
+import { pathToFileURL } from 'node:url';
 
 const log = fs.openSync(process.env.DC_TEST_MODULE_LOG, 'a');
+const record = (url, parentURL) => fs.writeSync(log, `${Date.now()} ${url} ${parentURL ?? ''}\n`);
 
-registerHooks({
-  resolve(specifier, context, nextResolve) {
-    const resolved = nextResolve(specifier, context);
-    fs.writeSync(log, `${Date.now()} ${resolved.url} ${context.parentURL ?? ''}\n`);
-    return resolved;
-  },
-});
+if (Module.registerHooks) {
+  Module.registerHooks({
+    resolve(specifier, context, nextResolve) {
+      const resolved = nextResolve(specifier, context);
+      record(resolved.url, context.parentURL);
+      return resolved;
+    },
+  });
+} else {
+  Module.register('./record-modules-hooks.mjs', import.meta.url);
+  const resolveFilename = Module._resolveFilename;
+  Module._resolveFilename = function (request, parent, ...rest) {
+    const filename = resolveFilename.call(this, request, parent, ...rest);
+    const url = Module.isBuiltin(filename) ? `node:${filename.replace(/^node:/, '')}` : pathToFileURL(filename).href;
+    record(url, parent?.filename && pathToFileURL(parent.filename).href);
+    return filename;
+  };
+}