test: use the real 22.7.0 AsyncContextFrame cutoff

Review nits from #397. AsyncContextFrame landed in 22.7.0, not at the 22
boundary, so several places named the wrong version.

Drop `&& satisfies(process.versions.node, '>=22.7.0')` from the four useCPED
definitions. It is redundant against isAsyncContextFrameActive(): ACF cannot be
active below 22.7.0, so the detection already answers false there. This leaves
semver unused in test-get-value-from-map-profiler.ts, so the import goes too.

Fix the cutoffs that were expressed as a bare major: the skip gates in
test-async-context-frame.ts now use a semver check, and the prose in
test-otel-thread-ctx.ts and in the async-context-frame doc comment names
22.7.0.

asyncContextFrameHint() had the only user-visible instance of the bug: on Node
22.0 through 22.6 it advised passing --experimental-async-context-frame, a flag
those versions do not have. Compared by major/minor rather than
semver.satisfies because semver is a devDependency and this module ships.
Boundary checked across 20.19.0, 22.6.0, 22.7.0, 22.23.2, 23.5.0 and 24.18.0.

124 passing on macOS, 175 passing / 2 pending in test:docker, unchanged.

Author: szegedi

ts/src/async-context-frame.ts

@@ -44,9 +44,10 @@ let active: boolean | undefined;
  * `process.execArgv`, because the two disagree in both directions and each
  * combination is reachable today:
  *
- * - `NODE_OPTIONS=--experimental-async-context-frame` is accepted on Node 22
- *   and 23 and turns ACF on without appearing in `execArgv`. Inferring "off"
- *   there makes callers refuse to run in a process that would have worked.
+ * - `NODE_OPTIONS=--experimental-async-context-frame` is accepted from Node
+ *   22.7.0 through 23 and turns ACF on without appearing in `execArgv`.
+ *   Inferring "off" there makes callers refuse to run in a process that would
+ *   have worked.
  * - `NODE_OPTIONS=--no-async-context-frame` is accepted on Node 24 and turns
  *   ACF off without appearing in `execArgv`. Inferring "on" there is the worse
  *   error: the CPED slot is never written, so a writer that starts anyway keeps
@@ -97,8 +98,10 @@ export function isAsyncContextFrameActive(): boolean {
  */
 export function asyncContextFrameHint(): string {
   const version = process.versions.node;
-  const major = Number(version.split('.')[0]);
-  if (major < 22) {
+  const [major, minor] = version.split('.').map(Number);
+  // Hand-rolled rather than semver.satisfies: semver is a devDependency, and
+  // this module ships.
+  if (major < 22 || (major === 22 && minor < 7)) {
     return `Node ${version} does not support it at all; Node 24 and later enable it by default`;
   }
   if (major < 24) {

ts/test/test-async-context-frame.ts

@@ -19,6 +19,8 @@ import {AsyncLocalStorage} from 'node:async_hooks';
 import {fork} from 'node:child_process';
 import {join} from 'node:path';
 
+import {satisfies} from 'semver';
+
 import {isAsyncContextFrameActive} from '../src/async-context-frame';
 
 const addon = require('node-gyp-build')(join(__dirname, '..', '..')) as {
@@ -28,6 +30,8 @@ const addon = require('node-gyp-build')(join(__dirname, '..', '..')) as {
 const CHILD = join(__dirname, 'async-context-frame-child.js');
 
 const major = Number(process.versions.node.split('.')[0]);
+// ACF landed in 22.7.0, so the opt-in routes are gated on that, not on major 22.
+const hasAcfSupport = satisfies(process.versions.node, '>=22.7.0');
 
 interface ChildReport {
   active: boolean;
@@ -84,7 +88,7 @@ describe('isAsyncContextFrameActive', () => {
   });
 
   it('reports it inactive when Node has no support for it', async function () {
-    if (major >= 22) return this.skip();
+    if (hasAcfSupport) return this.skip();
     const {active} = await probeChild();
     assert.equal(active, false);
   });
@@ -112,11 +116,11 @@ describe('isAsyncContextFrameActive', () => {
   });
 
   it('reports it active when NODE_OPTIONS turns it on', async function () {
-    // The mirror image, on the other Node line: 22 and 23 accept the flag in
+    // The mirror image, on the other Node line: 22.7.0 through 23 accept the flag in
     // NODE_OPTIONS (24 rejects it outright), again without it reaching execArgv,
     // so inferring from execArgv concludes ACF is off when it is on — and the
     // caller refuses to run in a process that would have worked.
-    if (major < 22 || major >= 24) return this.skip();
+    if (!hasAcfSupport || major >= 24) return this.skip();
     const {active, execArgv} = await probeChild({
       nodeOptions: '--experimental-async-context-frame',
     });

ts/test/test-get-value-from-map-profiler.ts

@@ -29,15 +29,13 @@
 import assert from 'assert';
 import {join} from 'path';
 import {AsyncLocalStorage} from 'async_hooks';
-import {satisfies} from 'semver';
 
 import {isAsyncContextFrameActive} from '../src/async-context-frame';
 
 const findBinding = require('node-gyp-build');
 const profiler = findBinding(join(__dirname, '..', '..'));
 
-const useCPED =
-  isAsyncContextFrameActive() && satisfies(process.versions.node, '>=22.7.0');
+const useCPED = isAsyncContextFrameActive();
 
 const supportedPlatform =
   process.platform === 'darwin' || process.platform === 'linux';

ts/test/test-otel-thread-ctx.ts

@@ -62,8 +62,9 @@ function tcIsTruncated(): boolean {
 }
 
 const isLinux = process.platform === 'linux';
-// AsyncContextFrame is the writer's discovery substrate: opt-in on Node 22/23
-// (via --experimental-async-context-frame) and on by default from Node 24
+// AsyncContextFrame is the writer's discovery substrate: opt-in from Node
+// 22.7.0 through 23 (via --experimental-async-context-frame) and on by
+// default from Node 24
 // (disable-able via --no-async-context-frame). The TS layer refuses to install
 // the hook when it isn't active, so the entire describe block is skipped then.
 // Asks the same question the source side asks, the same way.

ts/test/test-time-profiler.ts

@@ -32,8 +32,7 @@ import {fork} from 'child_process';
 
 import assert from 'assert';
 
-const useCPED =
-  isAsyncContextFrameActive() && satisfies(process.versions.node, '>=22.7.0');
+const useCPED = isAsyncContextFrameActive();
 
 const collectAsyncId = satisfies(process.versions.node, '>=24.0.0');
 

ts/test/worker.ts

@@ -12,10 +12,7 @@ const DURATION_MILLIS = 1000;
 const intervalMicros = 10000;
 const withContexts =
   process.platform === 'darwin' || process.platform === 'linux';
-const useCPED =
-  withContexts &&
-  isAsyncContextFrameActive() &&
-  satisfies(process.versions.node, '>=22.7.0');
+const useCPED = withContexts && isAsyncContextFrameActive();
 const collectAsyncId =
   withContexts && satisfies(process.versions.node, '>=24.0.0');
 

ts/test/worker2.ts

@@ -10,10 +10,7 @@ const INTERVAL_MICROS = 10000;
 const withContexts =
   process.platform === 'darwin' || process.platform === 'linux';
 
-const useCPED =
-  withContexts &&
-  isAsyncContextFrameActive() &&
-  satisfies(process.versions.node, '>=22.7.0');
+const useCPED = withContexts && isAsyncContextFrameActive();
 
 const collectAsyncId =
   withContexts && satisfies(process.versions.node, '>=24.0.0');