Fix npm test on Node 24+ and cover the teardown abort

Two things, both about being able to run the suite at all on current Node.

The test script passed --experimental-async-context-frame unconditionally.
Node 22/23 need it, but Node 24 turned AsyncContextFrame on by default and
removed the flag, so from Node 24 on `npm test` failed before running
anything:

    node: bad option: --experimental-async-context-frame

Replace it with a small runner in the style of build.js, which computes the
flag list from the running version. --disable-warning is conditional for the
same reason: it only exists from Node 21.3. The computation lives in
test/node-flags.js because the new test below needs it too, when spawning.

Then add the regression test for the CtxWrap teardown abort fixed in the
previous commit. 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, not 48 passes and
one failure — which is also why testing this inline was not an option.

npm test now: 49 pass / 0 fail on Node 22, 24 and 26. Previously 24 and 26
could not run it.

Author: szegedi

js/package.json

@@ -4,7 +4,7 @@
     "description": "Node.js writer for the OpenTelemetry thread-context record (OTEP-4947), discoverable via AsyncLocalStorage / AsyncContextFrame.",
     "main": "index.js",
     "scripts": {
-        "test": "node --experimental-async-context-frame --disable-warning=ExperimentalWarning --test test/test.js",
+        "test": "node test/run.js",
         "test:docker": "./test/run-in-docker.sh",
         "install": "node build.js"
     },

js/test/node-flags.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// Node flags needed to make AsyncContextFrame — the writer's discovery
+// substrate — available on the running Node.
+//
+// Node 22/23 need the --experimental-async-context-frame opt-in. Node 24
+// turned ACF on by default and *removed* the flag, so passing it there is a
+// hard `node: bad option` failure rather than a no-op. Anything that spawns a
+// Node process for these tests has to compute the list rather than hardcode
+// it; that includes `npm test` itself (see run.js).
+function acfFlags() {
+    const major = Number(process.versions.node.split('.')[0]);
+    return major >= 22 && major < 24 ? ['--experimental-async-context-frame'] : [];
+}
+
+module.exports = { acfFlags };

js/test/run.js

@@ -0,0 +1,36 @@
+'use strict';
+
+// `npm test` entry point.
+//
+// The script used to pass --experimental-async-context-frame unconditionally,
+// which works on Node 22/23 and fails outright from Node 24 on, where the flag
+// was removed:
+//
+//     node: bad option: --experimental-async-context-frame
+//
+// so `npm test` was broken on every current Node. Compute the flags instead.
+
+const { spawnSync } = require('node:child_process');
+const path = require('node:path');
+
+const { acfFlags } = require('./node-flags');
+
+const major = Number(process.versions.node.split('.')[0]);
+const flags = [...acfFlags()];
+// --disable-warning landed in Node 21.3; on older Node it would itself be a
+// bad option. Nothing below 22 can run these tests anyway (test.js bails).
+if (major >= 22) {
+    flags.push('--disable-warning=ExperimentalWarning');
+}
+
+const res = spawnSync(
+    process.execPath,
+    [...flags, '--test', path.join(__dirname, 'test.js')],
+    { stdio: 'inherit' },
+);
+
+if (res.error) {
+    console.error(res.error);
+    process.exit(1);
+}
+process.exit(res.status === null ? 1 : res.status);

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)) {