Add a regression test for the CtxWrap teardown abort

Covers the abort fixed in the previous commit: CtxWrap derived from
node::ObjectWrap, whose destructor calls RemoveEnvironmentCleanupHook, which
CHECKs that an Environment is current. A CtxWrap collected during isolate
teardown hit that CHECK and aborted the process.

It runs in a spawned process because the failure is a SIGABRT: `node --test`
runs the file in-process, so an abort takes the whole file down rather than
failing one test. Against the pre-fix addon the run reports `pass 0, fail 1`
with the CtxWrap::~CtxWrap stack rather than one failing test among the
passes, which is why testing this inline was not an option.

Spawning needs the same version-dependent flag list as the runner, so it uses
acfFlags() from test/node-flags.js.

Author: szegedi

js/test/teardown-child.js

@@ -0,0 +1,48 @@
+'use strict';
+
+// Spawned by the "contexts collected during isolate teardown" test. Runs in
+// its own process because the failure mode is a SIGABRT, which would take the
+// whole test run down with it.
+//
+// When CtxWrap derived from node::ObjectWrap, a CtxWrap collected during
+// isolate teardown ran ~ObjectWrap -> RemoveEnvironmentCleanupHook, which
+// CHECKs that an Environment is current. It is not, during teardown, so:
+//
+//     Assertion failed: (env) != nullptr
+//      3: otel_thread_ctx_nodejs::CtxWrap::~CtxWrap()
+//
+// It needs enough instances that V8 still has some left to collect at
+// teardown — nothing below ~1000 reproduced it — hence the count.
+
+const { ThreadContext } = require('..');
+
+const N = Number(process.argv[2] || 3000);
+
+function id(n, len) {
+    const b = Buffer.alloc(len);
+    b.writeUInt32BE(n >>> 0, 0);
+    return b;
+}
+
+const retained = [];
+
+for (let i = 0; i < N; i++) {
+    const ctx = new ThreadContext(id(i, 16), id(i, 8), ['k', String(i)]);
+    if (i % 4 === 0) {
+        // Still strongly reachable at exit.
+        retained.push(ctx);
+    } else {
+        // Reachable only through the async context frame, so collectable
+        // whenever V8 decides — including during teardown.
+        ctx.enter();
+    }
+}
+
+if (retained.length > 0) {
+    retained[0].enter();
+}
+globalThis.__retained = retained;
+
+// Exit through the normal path so the Environment is torn down and the
+// isolate disposed; that is where the weak callbacks in question fire.
+console.log(`created ${N}, retained ${retained.length}`);

js/test/test.js

@@ -33,6 +33,8 @@ if (!isAsyncContextFrameAvailable()) {
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 
+const { acfFlags } = require('./node-flags');
+
 const lib = require('..');
 const { ThreadContext, getContext, clearContext, getProcessContextAttributes, _currentRecordBytes } = lib;
 
@@ -597,6 +599,24 @@ test('appendAttributes after invalidate mutates attrs_data but leaves valid=0',
     });
 });
 
+// Regression test: CtxWrap used to derive from node::ObjectWrap, whose
+// destructor calls RemoveEnvironmentCleanupHook. A CtxWrap collected during
+// isolate teardown hit that function's CHECK that an Environment is current
+// and aborted the process. Spawned, because the failure is a SIGABRT rather
+// than an assertion failure.
+test('contexts collected during isolate teardown do not abort', () => {
+    const child = path.join(__dirname, 'teardown-child.js');
+    const r = spawnSync(process.execPath, [...acfFlags(), child, '3000'], {
+        encoding: 'utf8',
+    });
+    assert.equal(
+        r.status,
+        0,
+        `teardown-child exited with status=${r.status} signal=${r.signal}\n` +
+            `${r.stdout}${r.stderr}`,
+    );
+});
+
 test('otel_thread_ctx_nodejs_v1 is exported as a TLS dynsym', (t) => {
     const addon = path.join(__dirname, '..', 'build', 'Release', 'customlabels.node');
     if (!require('node:fs').existsSync(addon)) {