eslint-plugin-test-governance 0.7.0 → 0.8.1

package/CHANGELOG.md

@@ -6,6 +6,34 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-10-22
+
+### Fixed
+
+- In Playwright files, `const pw = require('@playwright/test')` and `import pw from '@playwright/test'`
+  are `test` itself, so `pw.skip(...)`, `pw.describe.fixme(...)` and `pw.test.skip(...)` are checked.
+  They were missed.
+- In Mocha, Cypress and WebdriverIO files, `mocha.it.skip(...)` after `import mocha from 'mocha'` is
+  checked, as it already was after `import * as mocha from 'mocha'` and `require('mocha')`.
+
+## [0.8.0] - 2026-10-22
+
+### Added
+
+- `node:test` support. `configs['node-test']`, or `configure({ framework: 'node-test' })`, checks tests
+  written with Node's built-in runner: `test`, `it`, `describe` and `suite` imported or required from
+  `node:test`, their `skip`, `todo` and `expectFailure` members, which `node:test` also exports by name,
+  and the same options. Node counts an option set to any value but `false` or `undefined`, so
+  `{ skip: 'broker sandbox is down' }` always skips and needs a ticket, while `{ skip: isWindows }` is a
+  conditional skip. `t.skip()` and `t.todo()` on a test's context, or `this.skip()` and `this.todo()` in a
+  `function`, count in a test, `beforeEach` and `afterEach`, and subtests declared with `t.test()` are
+  checked like tests. `expectFailure` is the `fail` state, which is off by default.
+
+### Fixed
+
+- A marker in the wrong case directly above a test in that state, as `// todo:` above `test.todo(...)`, is
+  reported once, by `require-ticket`, which asks for uppercase. `require-ticket-in-comments` reported it too.
+
 ## [0.7.0] - 2026-10-20
 
 ### Added
@@ -329,7 +357,9 @@ First release.
 - Support for ESLint 9 and 10 flat config, JavaScript and TypeScript test files, `.extend()`
   fixtures, describe blocks, runtime skips and tags in titles or the `tag` option.
 
-[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.7.0...HEAD
+[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.8.1...HEAD
+[0.8.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.8.0...v0.8.1
+[0.8.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.2...v0.7.0
 [0.6.2]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.1...v0.6.2
 [0.6.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.6.0...v0.6.1

package/README.md

@@ -4,7 +4,7 @@
 [![CI](https://github.com/Huldoser/eslint-plugin-test-governance/actions/workflows/ci.yml/badge.svg)](https://github.com/Huldoser/eslint-plugin-test-governance/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/npm/l/eslint-plugin-test-governance)](LICENSE)
 
-ESLint rules that keep a Playwright, Jest, Vitest, Mocha, Cypress or WebdriverIO suite honest. Every skipped, fixme, todo, `@new`
+ESLint rules that keep a Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO or `node:test` suite honest. Every skipped, fixme, todo, `@new`
 or `@quarantined` test must point at the ticket that tracks it:
 
 <!-- example: valid -->
@@ -35,8 +35,8 @@ Requires ESLint 9 or 10 with flat config, and Node.js 22.12 or later. For TypeSc
 ## Usage
 
 Pick the config for the framework your tests use, `configs.playwright`, `configs.jest`,
-`configs.vitest`, `configs.mocha`, `configs.cypress` or `configs.webdriverio`, and point it at those
-test files with `files`:
+`configs.vitest`, `configs.mocha`, `configs.cypress`, `configs.webdriverio` or `configs['node-test']` for
+Node's built-in runner, and point it at those test files with `files`:
 
 ```js
 // eslint.config.js
@@ -55,12 +55,14 @@ export default [
 There is no default config. Each framework declares, skips and tags tests its own way, so the rules
 need to know which one a file uses. In a Jest, Vitest or Mocha config, `test`, `it` and `describe` belong
 to that framework, whether they are globals or imported from `@jest/globals`, `vitest` or `mocha`, the
-way the Jest, Vitest and Mocha ESLint plugins are set up.
+way the Jest, Vitest and Mocha ESLint plugins are set up. `node:test` has no globals, so in its config
+they are the names imported or required from `node:test`, and `test` and `it` from `testFunctions`.
 
 Cypress and WebdriverIO run their tests on Mocha, so `configs.cypress` and `configs.webdriverio` read the
 same calls as `configs.mocha`. `webdriverio` means WebdriverIO's Mocha framework; its Jasmine framework
 isn't supported yet. Puppeteer has no test functions of its own, so use the config of the runner its
-tests run on: `configs.jest` for jest-puppeteer, or `configs.vitest` or `configs.mocha`.
+tests run on: `configs.jest` for jest-puppeteer, or `configs.vitest`, `configs.mocha` or
+`configs['node-test']`.
 
 With ESLint's `defineConfig()` (ESLint 9.22 or later), put the config in `extends`:
 
@@ -135,27 +137,36 @@ Each framework's config, such as `configs.playwright`, sets only the framework,
 `configure()` for the same files keeps that config's options and changes only the framework. They all
 turn on the same rules. What puts a test in a state in each framework:
 
-| State (marker)                         | Playwright                                                                                                          | Jest                                                                 | Vitest                                                                                                                                                                                     | Mocha                                                                                                                                                                     | Cypress                                  | WebdriverIO |
-| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | ----------- |
-| `skip` (`// SKIP:`)                    | `test.skip(...)`, `test.describe.skip`, `test.skip()` in a body, `testInfo.skip()`, `test.step.skip`, `step.skip()` | `test.skip`, `it.skip`, `describe.skip`, `xit`, `xtest`, `xdescribe` | `test.skip`, `it.skip`, `describe.skip`, `suite.skip`, `skipIf(true)`, `runIf(false)`, `{ skip: true }`, `context.skip()`, `context.skip('note')` or `skip()` in a body or in `beforeEach` | `it.skip`, `specify.skip`, `describe.skip`, `context.skip`, `xit`, `xspecify`, `xdescribe`, `xcontext`, TDD `test.skip` and `suite.skip`, `this.skip()` in a test or hook | as Mocha                                 | as Mocha    |
-| `todo` (`// TODO:`)                    |                                                                                                                     | `test.todo`, `it.todo`                                               | `test.todo`, `describe.todo`, `{ todo: true }`                                                                                                                                             | a test with only a title, `it('title')`, which Mocha runs as pending                                                                                                      | as Mocha                                 | as Mocha    |
-| `fixme` (`// FIXME:`)                  | `test.fixme(...)`, `test.describe.fixme`, `testInfo.fixme()`                                                        |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |
-| `fail` (`// FAIL:`), off by default    | `test.fail(...)`, `testInfo.fail()`                                                                                 | `test.failing`                                                       | `test.fails`, `{ fails: true }`                                                                                                                                                            |                                                                                                                                                                           |                                          |             |
-| `slow` (`// SLOW:`), off by default    | `test.slow()`, `testInfo.slow()`                                                                                    |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |
-| conditional skip, no ticket by default | `test.skip(condition)`, `if (...) test.skip()`, `(condition ? test.skip : test)(...)`                               | `(condition ? it.skip : it)(...)`                                    | `skipIf(condition)`, `runIf(condition)`, `{ skip: condition }`, `context.skip(condition)`, `if (...) context.skip()`, `(condition ? it.skip : it)(...)`                                    | `if (...) this.skip()`, `(condition ? it.skip : it)(...)`                                                                                                                 | as Mocha, and `{ browser: '!webkit' }`   | as Mocha    |
-| tags such as `@new` (`// NEW:`)        | the title, `{ tag }`                                                                                                | the title                                                            | the title, `{ tags }`, where `'new'` and `'@new'` both mean `@new`                                                                                                                         | the title                                                                                                                                                                 | the title, `{ tags }` from @cypress/grep | the title   |
+| State (marker)                         | Playwright                                                                                                          | Jest                                                                 | Vitest                                                                                                                                                                                     | Mocha                                                                                                                                                                     | Cypress                                  | WebdriverIO | node-test                                                                                                                                                                                         |
+| -------------------------------------- | ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `skip` (`// SKIP:`)                    | `test.skip(...)`, `test.describe.skip`, `test.skip()` in a body, `testInfo.skip()`, `test.step.skip`, `step.skip()` | `test.skip`, `it.skip`, `describe.skip`, `xit`, `xtest`, `xdescribe` | `test.skip`, `it.skip`, `describe.skip`, `suite.skip`, `skipIf(true)`, `runIf(false)`, `{ skip: true }`, `context.skip()`, `context.skip('note')` or `skip()` in a body or in `beforeEach` | `it.skip`, `specify.skip`, `describe.skip`, `context.skip`, `xit`, `xspecify`, `xdescribe`, `xcontext`, TDD `test.skip` and `suite.skip`, `this.skip()` in a test or hook | as Mocha                                 | as Mocha    | `test.skip`, `it.skip`, `describe.skip`, `suite.skip`, `skip()`, `{ skip: true }` or `{ skip: 'reason' }`, `t.skip()`, `t.skip('reason')` or `this.skip()` in a test, `beforeEach` or `afterEach` |
+| `todo` (`// TODO:`)                    |                                                                                                                     | `test.todo`, `it.todo`                                               | `test.todo`, `describe.todo`, `{ todo: true }`                                                                                                                                             | a test with only a title, `it('title')`, which Mocha runs as pending                                                                                                      | as Mocha                                 | as Mocha    | `test.todo`, `it.todo`, `describe.todo`, `suite.todo`, `todo()`, `{ todo: true }` or `{ todo: 'reason' }`, `t.todo()`, `this.todo()`                                                              |
+| `fixme` (`// FIXME:`)                  | `test.fixme(...)`, `test.describe.fixme`, `testInfo.fixme()`                                                        |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |                                                                                                                                                                                                   |
+| `fail` (`// FAIL:`), off by default    | `test.fail(...)`, `testInfo.fail()`                                                                                 | `test.failing`                                                       | `test.fails`, `{ fails: true }`                                                                                                                                                            |                                                                                                                                                                           |                                          |             | `test.expectFailure`, `expectFailure()`, `{ expectFailure }`                                                                                                                                      |
+| `slow` (`// SLOW:`), off by default    | `test.slow()`, `testInfo.slow()`                                                                                    |                                                                      |                                                                                                                                                                                            |                                                                                                                                                                           |                                          |             |                                                                                                                                                                                                   |
+| conditional skip, no ticket by default | `test.skip(condition)`, `if (...) test.skip()`, `(condition ? test.skip : test)(...)`                               | `(condition ? it.skip : it)(...)`                                    | `skipIf(condition)`, `runIf(condition)`, `{ skip: condition }`, `context.skip(condition)`, `if (...) context.skip()`, `(condition ? it.skip : it)(...)`                                    | `if (...) this.skip()`, `(condition ? it.skip : it)(...)`                                                                                                                 | as Mocha, and `{ browser: '!webkit' }`   | as Mocha    | `{ skip: condition }`, `{ todo: condition }`, `if (...) t.skip()`, `(condition ? it.skip : it)(...)`                                                                                              |
+| tags such as `@new` (`// NEW:`)        | the title, `{ tag }`                                                                                                | the title                                                            | the title, `{ tags }`, where `'new'` and `'@new'` both mean `@new`                                                                                                                         | the title                                                                                                                                                                 | the title, `{ tags }` from @cypress/grep | the title   | the title                                                                                                                                                                                         |
 
 Table-driven tests count too: `test.skip.each(table)(...)`, `describe.skip.each` and Vitest's `.for`.
 A test or describe whose function a condition picks, as in `(isMobile ? test.skip : test)('title', fn)`,
 is a conditional skip in every framework.
 A literal condition decides on its own: `skipIf(true)` and `runIf(false)` always skip, and `skipIf(false)`,
 `runIf(true)` and `{ skip: false }` never do.
-In Vitest and Mocha, `test.skip('title')` and `describe.skip('title')` with no body are skipped too.
+In Vitest, Mocha and `node:test`, `test.skip('title')` and `describe.skip('title')` with no body are skipped too.
 In Mocha, `this.skip()` counts in a test or hook written as a `function`; an arrow function gets no
 Mocha context, so its `this` is not the test's. `this.slow(ms)` only sets Mocha's speed threshold, so
 it isn't the `slow` state.
 Vitest writes tag names without the `@`, as in `{ tags: ['flaky'] }`, so a name in `tags` counts as the
 tag with an `@` in front: `'flaky'` is `@flaky`, and a custom state with `when: '@flaky'` matches it.
+In `node:test`, an option counts with any value but `false` or `undefined`, as Node reads it, so
+`{ skip: 'broker sandbox is down' }` always skips. `t.skip()` and `t.todo()` take a message, not a
+condition, and in a test or hook written as a `function`, `this.skip()` and `this.todo()` do the same.
+Subtests declared with `t.test('title', options, fn)` are checked like tests, and a test or describe can
+leave out its title and start with its options or body, as in `test({ skip: true }, fn)`.
+A test with no function, `test('title')`, passes in Node, so it isn't a todo. A describe's body, and
+`before` and `after` inside it, get the suite's context, which can't skip. Node reports a test in one
+state only, skip before todo before `expectFailure`, so `describe.skip('title', { todo: 'why' }, fn)`
+needs only a `// SKIP:` marker.
 
 ## Rules
 
@@ -166,19 +177,20 @@ tag with an `@` in front: `'flaky'` is `@flaky`, and a custom state with `when:
 🌲 Set in the `cypress` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 🃏 Set in the `jest` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 ☕ Set in the `mocha` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
+🟢 Set in the `node-test` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 🎭 Set in the `playwright` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 ⚡ Set in the `vitest` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 🤖 Set in the `webdriverio` [configuration](https://github.com/Huldoser/eslint-plugin-test-governance#usage).\
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
 💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
-| Name                                                                   | Description                                                                       | 💼                | ⚠️                | 🔧  | 💡  |
-| :--------------------------------------------------------------------- | :-------------------------------------------------------------------------------- | :---------------- | :---------------- | :-- | :-- |
-| [marker-matches-state](docs/rules/marker-matches-state.md)             | Require the marker keyword to match the test's state                              | 🌲 🃏 ☕ 🎭 ⚡ 🤖 |                   |     | 💡  |
-| [no-conflicting-states](docs/rules/no-conflicting-states.md)           | Disallow state tags that contradict each other, differ in case or look like typos |                   | 🌲 🃏 ☕ 🎭 ⚡ 🤖 | 🔧  |     |
-| [no-orphaned-marker](docs/rules/no-orphaned-marker.md)                 | Disallow marker comments that no longer match a test state                        | 🌲 🃏 ☕ 🎭 ⚡ 🤖 |                   |     | 💡  |
-| [require-ticket](docs/rules/require-ticket.md)                         | Require a ticket marker comment above skipped, fixme and tagged tests             | 🌲 🃏 ☕ 🎭 ⚡ 🤖 |                   |     | 💡  |
-| [require-ticket-in-comments](docs/rules/require-ticket-in-comments.md) | Require FIXME and TODO comments in test files to start with a ticket              | 🌲 🃏 ☕ 🎭 ⚡ 🤖 |                   |     | 💡  |
+| Name                                                                   | Description                                                                       | 💼                   | ⚠️                   | 🔧  | 💡  |
+| :--------------------------------------------------------------------- | :-------------------------------------------------------------------------------- | :------------------- | :------------------- | :-- | :-- |
+| [marker-matches-state](docs/rules/marker-matches-state.md)             | Require the marker keyword to match the test's state                              | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
+| [no-conflicting-states](docs/rules/no-conflicting-states.md)           | Disallow state tags that contradict each other, differ in case or look like typos |                      | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 | 🔧  |     |
+| [no-orphaned-marker](docs/rules/no-orphaned-marker.md)                 | Disallow marker comments that no longer match a test state                        | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
+| [require-ticket](docs/rules/require-ticket.md)                         | Require a ticket marker comment above skipped, fixme and tagged tests             | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
+| [require-ticket-in-comments](docs/rules/require-ticket-in-comments.md) | Require FIXME and TODO comments in test files to start with a ticket              | 🌲 🃏 ☕ 🟢 🎭 ⚡ 🤖 |                      |     | 💡  |
 
 <!-- end auto-generated rules list -->
 
@@ -290,8 +302,9 @@ In Playwright files:
 - `test` imported from `@playwright/test`, `playwright/test` or a component-testing package such as
   `@playwright/experimental-ct-react`, including the default import, aliases such as
   `import { test as it }` or `const it = test`, and `const { test } = require('@playwright/test')`.
-- `pw.test` on the whole module, after `import * as pw from '@playwright/test'` or
-  `const pw = require('@playwright/test')`.
+- `pw.test` on the whole module, after `import * as pw from '@playwright/test'`. The default import
+  and `const pw = require('@playwright/test')` are `test` itself, so `pw.skip(...)` and
+  `pw.test.skip(...)` both count.
 - Fixtures made with `.extend()` or `mergeTests()` in the same file, such as
   `const test = base.extend({...})`.
 - Any name in `testFunctions`, for fixtures imported from your own modules. The default `['test']`
@@ -310,9 +323,20 @@ In Mocha, Cypress and WebdriverIO files:
 - The globals `it`, `specify`, `describe` and `context`, their `x` forms, the TDD names `suite` and
   `test`, and the hooks `before`, `beforeEach`, `after`, `afterEach`, `suiteSetup`, `setup`,
   `suiteTeardown` and `teardown`.
-- The names imported or required from `mocha`, including aliases and `import * as mocha from 'mocha'`.
+- The names imported or required from `mocha`, including aliases, and the whole module, as `mocha.it`
+  after `import * as mocha from 'mocha'`, `import mocha from 'mocha'` or `const mocha = require('mocha')`.
 - Any name in `testFunctions`, which defaults to `['it', 'specify', 'test']`.
 
+In `node:test` files:
+
+- `test`, `it`, `describe`, `suite`, the hooks `before`, `beforeEach`, `after` and `afterEach`, and
+  the members exported by name, `skip`, `todo`, `only` and `expectFailure`, imported or required from
+  `node:test`, including aliases and `import * as nodeTest from 'node:test'`. The module is `test`
+  itself, so after `import test from 'node:test'` or `const test = require('node:test')`,
+  `test.describe(...)` is a describe.
+- Subtests: `t.test(...)` on the context a test's body receives.
+- Any name in `testFunctions`, which defaults to `['test', 'it']`. `node:test` has no globals.
+
 A name imported or required from another test runner (Playwright, `vitest`, `@jest/globals`,
 `node:test`, `bun:test`, `mocha`, `ava`, `tap`, `uvu`), or a variable set from one such as
 `const test = require('ava')`, is never treated as the framework's `test`, and neither is a local
@@ -342,7 +366,8 @@ Not covered in this version: tests generated in loops with dynamic titles, and t
 from other modules (see `reportUnreadableTags`), fixtures imported from other modules under a name not in
 `testFunctions`, a Vitest test with only a title, which Vitest runs as a todo but which looks the same as a
 helper called `test`, Playwright annotations as markers, Cypress tests skipped with @cypress/skip-test's
-`skipOn()` and `onlyOn()`, and other runners such as Jasmine, Bun and `node:test`.
+`skipOn()` and `onlyOn()`, `node:test`'s experimental `tags` option and `getTestContext()`, and other
+runners such as Jasmine and Bun.
 
 ## TypeScript
 

package/dist/index.d.ts

@@ -33,5 +33,5 @@ declare const plugin: TestGovernancePlugin;
  * so all rules read the same ticket formats and states.
  */
 export declare function configure(options: GovernanceOptions): FlatConfig;
-export declare const configs: Record<"playwright" | "jest" | "vitest" | "mocha" | "cypress" | "webdriverio", FlatConfig>;
+export declare const configs: Record<"playwright" | "jest" | "vitest" | "mocha" | "cypress" | "webdriverio" | "node-test", FlatConfig>;
 export default plugin;

package/dist/index.js

@@ -52,7 +52,7 @@ for (const framework of FRAMEWORK_NAMES) {
 // tools that list the configs don't see it.
 Object.defineProperty(plugin.configs, 'recommended', {
     get() {
-        throw new ConfigError('configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress or configs.webdriverio. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md');
+        throw new ConfigError("configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio or configs['node-test']. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md");
     },
 });
 export const configs = plugin.configs;

package/dist/rules/require-ticket-in-comments.js

@@ -1,4 +1,4 @@
-import { appliesTo, commentLines, isStateMarker, parseTickets } from "../utils/analyze.js";
+import { appliesTo, commentLines, parseTickets } from "../utils/analyze.js";
 import { createRule } from "../utils/create-rule.js";
 import { compileTicketSpec } from "../utils/tickets.js";
 /** Recognises anything shaped like a ticket, to tell a wrong-format ticket from plain prose. */
@@ -30,11 +30,13 @@ export default createRule({
             return;
         const { sourceCode } = context;
         const matcher = options.commentTicket;
-        // A marker directly above a test in that state belongs to require-ticket.
+        // A marker directly above a test in that state belongs to require-ticket, which also reports one
+        // in the wrong case.
         const owned = new Set();
         for (const subject of analysis.subjects) {
             for (const marker of subject.markers) {
-                if (isStateMarker(marker) && appliesTo(subject, marker.state.name))
+                const state = marker.state ?? marker.caseOf;
+                if (state && appliesTo(subject, state.name))
                     owned.add(marker.comment);
             }
         }

package/dist/utils/analyze.js

@@ -138,6 +138,9 @@ function collectTestNames(program, framework, configured) {
                     else if (spec.type === 'ImportDefaultSpecifier') {
                         if (framework.defaultExport)
                             roots.set(local, framework.defaultExport);
+                        // `import test from 'node:test'` also has `test.describe`, and `import mocha from 'mocha'` has `mocha.it`.
+                        if (framework.moduleIsDefault)
+                            modules.add(local);
                     }
                     else {
                         const root = framework.exports.get(importedName(spec));
@@ -167,10 +170,14 @@ function collectTestNames(program, framework, configured) {
                 else if (isOtherFramework(init))
                     setOther(name);
                 else {
-                    // `const pw = require('@playwright/test')`, used as `pw.test`.
+                    // `const mocha = require('mocha')`, used as `mocha.it`, or `const pw = require('@playwright/test')`,
+                    // which is `test` itself, as `require('node:test')` is.
                     const source = requireSource(init);
-                    if (source !== undefined && framework.ownsModule(source))
+                    if (source !== undefined && framework.ownsModule(source)) {
                         modules.add(name);
+                        if (framework.moduleIsDefault && framework.defaultExport)
+                            roots.set(name, framework.defaultExport);
+                    }
                 }
             }
             else if (declarator.id.type === 'ObjectPattern') {
@@ -443,10 +450,10 @@ function readTexts(sourceCode, node, out, via, path = []) {
 /**
  * The details or options object of a declaration, the second argument in
  * `test('title', { tag: '@smoke' }, fn)` or Vitest's `test('title', { skip: true }, fn)`, also when it
- * is a constant declared in this file.
+ * is a constant declared in this file. With `optionsFirst`, the first: node:test's `test({ skip: true }, fn)`.
  */
-function detailsOf(sourceCode, call) {
-    const details = call.arguments.at(1);
+function detailsOf(sourceCode, call, optionsFirst) {
+    const details = call.arguments.at(optionsFirst ? 0 : 1);
     if (details === undefined || isFunction(details))
         return { entries: [] };
     const target = unwrap(details);
@@ -455,7 +462,9 @@ function detailsOf(sourceCode, call) {
     if (object?.type !== 'ObjectExpression') {
         // A name that can't be read is the details object only when a body comes after it:
         // `test.skip('places an order', placeOrder)` has a body defined elsewhere and no details.
-        return call.arguments.slice(2).some(isFunction) ? { entries: [], unread: details } : { entries: [] };
+        return call.arguments.slice(optionsFirst ? 1 : 2).some(isFunction)
+            ? { entries: [], unread: details }
+            : { entries: [] };
     }
     const entries = object.properties.flatMap((prop) => {
         if (prop.type !== 'Property' || prop.computed)
@@ -492,6 +501,20 @@ function collectTags(sourceCode, call, hasTitle, framework, details) {
         unread.push(details.unread);
     return { tags, dynamic: title.unread.size > 0, unread, opaqueDetails: details.unread !== undefined };
 }
+/** Whether `node` is an object written out or held in a constant declared in this file. */
+function isObject(sourceCode, node) {
+    const target = unwrap(node);
+    const value = target.type === 'ObjectExpression' ? target : constantValue(sourceCode, target);
+    return value !== undefined && unwrap(value).type === 'ObjectExpression';
+}
+/**
+ * Whether a declaration leaves out its title: a describe with only a body, or in node:test any test or
+ * describe that starts with its body or its options.
+ */
+function leavesOutTitle(sourceCode, framework, args) {
+    const [first] = args;
+    return isFunction(first) || (framework.optionalTitle && isObject(sourceCode, first));
+}
 /** Whether a title is text, written out or held in a constant declared in this file. */
 function isTextTitle(sourceCode, node) {
     const title = unwrap(node);
@@ -501,17 +524,21 @@ function isTextTitle(sourceCode, node) {
 /**
  * Whether a call declares a test or describe block: a title and a body, as in `test('title', fn)`,
  * `test('title', details, fn)` or `test.skip(title, payWithCard)` with the body defined elsewhere, a
- * describe with only a body, or a `todo` with only a title, in Vitest and Mocha a `skip` with only a
- * title, and in Mocha a test with only a title written out, which it runs as pending.
+ * describe with only a body, or a `todo` with only a title, in Vitest, Mocha and node:test a `skip` with
+ * only a title, in Mocha a test with only a title written out, which it runs as pending, and in node:test
+ * a test or describe with no title.
  * Only Playwright has a runtime `test.skip(isMobile, 'why')`; there a title, written out or held in a
  * constant, or a body written in place tells the two apart.
  */
 function isDeclaration(sourceCode, framework, kind, args, members) {
     const first = args.at(0);
     if (isFunction(first))
-        return kind === 'describe';
+        return kind === 'describe' || framework.optionalTitle;
     if (first === undefined)
         return false;
+    // node:test's `test({ skip: true }, fn)`, or `test({ name, fn })` with everything in the options.
+    if (framework.optionalTitle && isObject(sourceCode, first))
+        return true;
     if (args.length === 1) {
         if (members.includes('todo') || (framework.skipWithoutBody && members.includes('skip')))
             return true;
@@ -533,6 +560,29 @@ function thisFunction(node) {
 function booleanOf(node) {
     return node?.type === 'Literal' && typeof node.value === 'boolean' ? node.value : undefined;
 }
+/**
+ * Whether a node:test option applies: Node counts any value but `false` and `undefined`, so a reason such
+ * as `{ skip: 'flaky' }`, `''`, `0`, `null`, and an `expectFailure` pattern or matcher always do. Undefined
+ * for a value only known when the test runs, such as `{ skip: isWindows }`.
+ */
+function optionApplies(node) {
+    const value = unwrap(node);
+    if (value.type === 'Identifier' && value.name === 'undefined')
+        return false;
+    if (value.type === 'Literal')
+        return value.value !== false;
+    return OPTION_VALUES.has(value.type) ? true : undefined;
+}
+/** Values that are never `false` or `undefined`. */
+const OPTION_VALUES = new Set([
+    'TemplateLiteral',
+    'ObjectExpression',
+    'ArrayExpression',
+    'ArrowFunctionExpression',
+    'FunctionExpression',
+    'ClassExpression',
+    'NewExpression',
+]);
 /**
  * Whether a runtime call always applies: it has no condition, or `true`, or with `notes` only a note, as
  * Vitest's `context.skip('Broker sandbox is down')`, and nothing around it makes it conditional.
@@ -623,8 +673,10 @@ function runAnalysis(sourceCode, options) {
         const { root, path, args } = chain;
         let base = testNames.roots.get(root.name);
         let rest = path;
-        if (base === undefined && testNames.modules.has(root.name)) {
-            base = framework.exports.get(path[0]);
+        // `pw.test.skip`, or node:test's `test.describe`, whose module is also its `test`.
+        const member = testNames.modules.has(root.name) ? framework.exports.get(path[0]) : undefined;
+        if (member !== undefined || base === undefined) {
+            base = member;
             rest = path.slice(1);
         }
         return base !== undefined && !isLocalVariable(sourceCode, root) ? { root: base, path: rest, args } : undefined;
@@ -738,10 +790,14 @@ function runAnalysis(sourceCode, options) {
         // `{ skip: true }` always skips, `{ skip: isMobile }` only sometimes, `{ skip: false }` never.
         for (const [key, value] of details) {
             const modifier = framework.optionEffects.get(key);
-            const literal = booleanOf(value);
-            if (modifier && literal !== false)
-                add(modifier, literal === true);
+            const always = framework.anyOptionValue ? optionApplies(value) : booleanOf(value);
+            if (modifier && always !== false)
+                add(modifier, always === true);
         }
+        const first = framework.exclusiveStates.findIndex((state) => modifiers.get(state) === true);
+        if (first !== -1)
+            for (const state of framework.exclusiveStates.slice(first + 1))
+                modifiers.delete(state);
         return modifiers;
     };
     /**
@@ -754,10 +810,10 @@ function runAnalysis(sourceCode, options) {
         }
         return modifiers;
     };
-    /** Keeps the body of a Mocha test or hook written as a `function`, whose `this` can skip it. */
+    /** Keeps the body of a test or hook written as a `function`, whose `this` can skip it, as in Mocha. */
     const addThisBody = (args) => {
         const body = args.findLast(isFunction);
-        if (framework.thisSkip && body?.type === 'FunctionExpression')
+        if (body?.type === 'FunctionExpression')
             thisBodies.add(body);
     };
     /** What a body can change the test's state with: Playwright's `testInfo` or Vitest's test context. */
@@ -803,8 +859,7 @@ function runAnalysis(sourceCode, options) {
         if (yes.kind !== no.kind || !declares(yes, args) || !declares(no, args))
             return undefined;
         usesTest = true;
-        const details = detailsOf(sourceCode, call);
-        const tagInfo = collectTags(sourceCode, call, !isFunction(args[0]), framework, details);
+        const { details, tagInfo } = headOf(call);
         const [ifYes, ifNo] = [yes, no].map(({ members, args: conditions }) => declarationModifiers(yes.kind, args, modifiersOf(members, details.entries, conditions)));
         if (yes.kind === 'test')
             addThisBody(args);
@@ -812,12 +867,41 @@ function runAnalysis(sourceCode, options) {
         for (const modifier of new Set([...ifYes.keys(), ...ifNo.keys()])) {
             modifiers.set(modifier, ifYes.get(modifier) === true && ifNo.get(modifier) === true);
         }
-        return { subject: makeSubject(yes.kind, call, modifiers, tagInfo), infos: bodyInfos(args, yes.members) };
+        const infos = yes.kind === 'test' ? bodyInfos(args, yes.members) : [];
+        return { subject: makeSubject(yes.kind, call, modifiers, tagInfo), infos };
+    };
+    /** The details and tags of a declaration; node:test lets it leave out its title. */
+    const headOf = (call) => {
+        const args = call.arguments;
+        const untitled = leavesOutTitle(sourceCode, framework, args);
+        const details = detailsOf(sourceCode, call, untitled && !isFunction(args[0]));
+        return { details, tagInfo: collectTags(sourceCode, call, !untitled, framework, details) };
+    };
+    const declare = (call, { kind, members, args: conditions }, infos) => {
+        const args = call.arguments;
+        const { details, tagInfo } = headOf(call);
+        const modifiers = declarationModifiers(kind, args, modifiersOf(members, details.entries, conditions));
+        if (kind === 'test')
+            addThisBody(args);
+        return { subject: makeSubject(kind, call, modifiers, tagInfo), infos };
+    };
+    /** node:test's `t.test('title', fn)`: a subtest declared through the context of the test around it. */
+    const subtestOf = (call) => {
+        const { callee } = call;
+        if (!framework.subtests || callee.type !== 'MemberExpression' || memberName(callee) !== 'test')
+            return undefined;
+        const { object } = callee;
+        if (object.type !== 'Identifier' || !infos.findLast((info) => info.name === object.name)?.methods)
+            return undefined;
+        const declaration = { kind: 'test', members: [], args: new Map() };
+        return declares(declaration, call.arguments)
+            ? declare(call, declaration, bodyInfos(call.arguments, []))
+            : undefined;
     };
     const visitCall = (call) => {
         const callee = target(chainOf(call.callee, framework.factories));
         if (callee === undefined)
-            return pickedDeclaration(call) ?? { subject: runtimeCall(call) };
+            return subtestOf(call) ?? pickedDeclaration(call) ?? { subject: runtimeCall(call) };
         usesTest = true;
         const args = call.arguments;
         const { path } = callee;
@@ -825,6 +909,8 @@ function runAnalysis(sourceCode, options) {
         // Vitest's `beforeEach((context) => context.skip())` and Mocha's `before(function () { this.skip(); })`
         // skip the tests they run for.
         if (declaration === undefined) {
+            if (callee.root.noContext)
+                return { infos: [] };
             addThisBody(args);
             return { infos: bodyInfos(args, path) };
         }
@@ -839,17 +925,11 @@ function runAnalysis(sourceCode, options) {
                 return { subject, infos: infoNames(param, STEP_INFO_METHODS, subject) };
             }
         }
-        const bodyInfo = bodyInfos(args, path);
         const { kind, members } = declaration;
-        if (declares(declaration, args)) {
-            // A declaration always has a first argument: its title, or the body of a describe without one.
-            const details = detailsOf(sourceCode, call);
-            const tagInfo = collectTags(sourceCode, call, !isFunction(args[0]), framework, details);
-            const modifiers = declarationModifiers(kind, args, modifiersOf(members, details.entries, callee.args));
-            if (kind === 'test')
-                addThisBody(args);
-            return { subject: makeSubject(kind, call, modifiers, tagInfo), infos: bodyInfo };
-        }
+        // A describe's body gets no test context: node:test passes one that can't skip.
+        const bodyInfo = kind === 'describe' ? [] : bodyInfos(args, path);
+        if (declares(declaration, args))
+            return declare(call, declaration, bodyInfo);
         // test.skip(), test.fixme(), test.fail() and test.slow() in a test, a describe or a hook.
         if (framework.playwright && members.length === 1 && RUNTIME_MODIFIERS.has(members[0])) {
             return { subject: runtimeSubject(call, members[0]), infos: bodyInfo };
@@ -857,8 +937,8 @@ function runAnalysis(sourceCode, options) {
         return { infos: bodyInfo };
     };
     /**
-     * `testInfo.skip()`, `step.skip()`, `test.info().skip()`, Vitest's `context.skip()` or `skip()`, and
-     * Mocha's `this.skip()`.
+     * `testInfo.skip()`, `step.skip()`, `test.info().skip()`, Vitest's `context.skip()` or `skip()`,
+     * Mocha's `this.skip()`, and node:test's `t.skip()` and `t.todo()`.
      */
     const runtimeCall = (call) => {
         const { callee } = call;
@@ -871,19 +951,21 @@ function runAnalysis(sourceCode, options) {
         if (callee.type !== 'MemberExpression')
             return undefined;
         const name = memberName(callee);
-        if (name === undefined || !RUNTIME_MODIFIERS.has(name))
+        if (name === undefined)
             return undefined;
         const { object } = callee;
-        // Mocha's `this.skip()`, in a test or hook whose `function` gives it the test's `this`.
+        // Mocha's `this.skip()` or node:test's `this.todo()`, in a test or hook whose `function` gives it the
+        // test's `this`.
         if (object.type === 'ThisExpression') {
-            const owner = name === 'skip' ? thisFunction(call) : undefined;
+            const owner = framework.thisMethods.has(name) ? thisFunction(call) : undefined;
             return owner !== undefined && thisBodies.has(owner) ? runtimeSubject(call, name) : undefined;
         }
         if (object.type === 'Identifier') {
             const info = innermost(object.name);
             return info?.methods?.has(name) ? runtimeSubject(call, name, info.step) : undefined;
         }
-        const isTestInfo = object.type === 'CallExpression' &&
+        const isTestInfo = RUNTIME_MODIFIERS.has(name) &&
+            object.type === 'CallExpression' &&
             target(chainOf(object.callee, framework.factories))?.path.join('.') === 'info';
         return isTestInfo ? runtimeSubject(call, name) : undefined;
     };
@@ -1011,9 +1093,10 @@ export function headLoc(subject) {
     const { node } = subject;
     if (subject.kind === 'runtime')
         return node.loc;
-    // A describe can have a body and no title. A todo test has only a title.
+    // A describe, or in node:test any declaration, can start with its body or options and have no title. A
+    // todo test has only a title.
     const [first] = node.arguments;
-    const title = isFunction(first) ? undefined : first;
+    const title = isFunction(first) || first.type === 'ObjectExpression' ? undefined : first;
     return { start: node.callee.loc.start, end: (title ?? node.callee).loc.end };
 }
 export function describeSubject(subject) {

package/dist/utils/constants.d.ts

@@ -8,7 +8,7 @@ export type BuiltinStateName = (typeof BUILTIN_STATE_NAMES)[number];
 export declare const TAG_STATE_NAMES: readonly ["new", "quarantined"];
 export type TagStateName = (typeof TAG_STATE_NAMES)[number];
 /** The test frameworks the rules understand. */
-export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest", "mocha", "cypress", "webdriverio"];
+export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest", "mocha", "cypress", "webdriverio", "node-test"];
 export type FrameworkName = (typeof FRAMEWORK_NAMES)[number];
 export declare const TICKET_PRESETS: readonly ["any", "jira", "github", "gitlab", "linear", "azure-devops", "numeric", "pattern"];
 /** Comment keywords that must reference a ticket by default (`// TODO: TRADE-123`). */

package/dist/utils/constants.js

@@ -6,7 +6,15 @@ export const BUILTIN_STATE_NAMES = ['skip', 'fixme', 'fail', 'slow', 'todo', 'ne
 /** The built-in states a tag puts a test in, so the only ones whose tag can be renamed. */
 export const TAG_STATE_NAMES = ['new', 'quarantined'];
 /** The test frameworks the rules understand. */
-export const FRAMEWORK_NAMES = ['playwright', 'jest', 'vitest', 'mocha', 'cypress', 'webdriverio'];
+export const FRAMEWORK_NAMES = [
+    'playwright',
+    'jest',
+    'vitest',
+    'mocha',
+    'cypress',
+    'webdriverio',
+    'node-test',
+];
 export const TICKET_PRESETS = [
     'any',
     'jira',

package/dist/utils/frameworks.d.ts

@@ -8,6 +8,8 @@ export type Modifier = 'skip' | 'fixme' | 'fail' | 'slow' | 'todo';
 export interface Root {
     kind: 'test' | 'describe' | 'hook';
     modifiers: readonly string[];
+    /** Set for a hook whose body gets no test context, as node:test's `before` in a describe. */
+    noContext?: true;
 }
 /**
  * The state a member puts a test in. A member called with a condition, like Vitest's `skipIf(...)`, puts it
@@ -27,6 +29,11 @@ export interface Framework {
     exports: ReadonlyMap<string, Root>;
     /** What a default import from the framework's module is. */
     defaultExport?: Root;
+    /**
+     * Whether the default export is the module itself, with the other functions as members: node:test's and
+     * Playwright's are `test`, which has `test.describe`, and Mocha's has `mocha.it`.
+     */
+    moduleIsDefault: boolean;
     /** Test functions that exist without an import, besides `testFunctions`. */
     globals: ReadonlyMap<string, Root>;
     /** The default `testFunctions`. */
@@ -43,6 +50,21 @@ export interface Framework {
     effects: ReadonlyMap<string, Effect>;
     /** Keys of an options object that put a test in a state, as in Vitest's `{ skip: true }`. */
     optionEffects: ReadonlyMap<string, Modifier>;
+    /**
+     * Whether an option counts whatever its value, unless it is `false` or `undefined`, as node:test's
+     * `{ skip: 'reason' }`. Otherwise only `true` always counts and other values are conditions.
+     */
+    anyOptionValue: boolean;
+    /**
+     * States a test is in only one of: the first that always applies, as node:test reports a skipped todo
+     * test as skipped only. A state that applies only sometimes leaves the later ones for the other runs.
+     */
+    exclusiveStates: readonly Modifier[];
+    /**
+     * Whether the title can be left out, as node:test's `test(fn)` and `test({ skip: true }, fn)`, and an
+     * options object then comes first.
+     */
+    optionalTitle: boolean;
     /** The key of the details or options object that holds tags. */
     tagKey?: string;
     /** Whether that key holds names without their `@`, as Vitest's `tags: ['flaky']`, which stand for `@flaky`. */
@@ -55,6 +77,8 @@ export interface Framework {
         param: number;
         methods: ReadonlySet<string>;
     };
+    /** Whether that parameter declares subtests with `t.test(...)`, as in node:test. */
+    subtests: boolean;
     /** Whether `skip` with only a title declares a skipped test or describe, as Vitest's `test.skip('title')`. */
     skipWithoutBody: boolean;
     /**
@@ -62,8 +86,11 @@ export interface Framework {
      * `context.skip('why')`. In Playwright the first argument is always a condition.
      */
     skipNotes: boolean;
-    /** Whether a test or hook written as a `function` can skip at runtime with `this.skip()`, as in Mocha. */
-    thisSkip: boolean;
+    /**
+     * The methods a test or hook written as a `function` can change its state with at runtime through `this`,
+     * as Mocha's `this.skip()`. Empty when `this` can't.
+     */
+    thisMethods: ReadonlySet<string>;
     /** Whether a test with only a title written out is a todo, as Mocha's pending `it('title')`. */
     todoWithoutBody: boolean;
     /** Built-in states a test can be put in with this framework. */

package/dist/utils/frameworks.js

@@ -16,6 +16,7 @@ const playwright = {
     ownsModule: isPlaywrightModule,
     exports: new Map([['test', TEST]]),
     defaultExport: TEST,
+    moduleIsDefault: true,
     globals: new Map(),
     testFunctions: ['test'],
     testMembers: new Set(['only', 'skip', 'fixme', 'fail']),
@@ -27,12 +28,16 @@ const playwright = {
         ['fail', 'fail'],
     ]),
     optionEffects: new Map(),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
     tagKey: 'tag',
     plainTags: false,
     info: { param: 1, methods: RUNTIME_MODIFIERS },
+    subtests: false,
     skipWithoutBody: false,
     skipNotes: false,
-    thisSkip: false,
+    thisMethods: new Set(),
     todoWithoutBody: false,
     states: new Set(['skip', 'fixme', 'fail', 'slow', 'new', 'quarantined']),
     playwright: true,
@@ -51,6 +56,7 @@ const jest = {
     name: 'jest',
     ownsModule: (source) => source === '@jest/globals',
     exports: JEST_FUNCTIONS,
+    moduleIsDefault: false,
     globals: new Map([...JEST_FUNCTIONS].filter(([name]) => name !== 'test' && name !== 'it')),
     testFunctions: ['test', 'it'],
     testMembers: new Set(['only', 'skip', 'todo', 'failing', 'concurrent', 'each()']),
@@ -62,10 +68,14 @@ const jest = {
         ['failing', 'fail'],
     ]),
     optionEffects: new Map(),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
     plainTags: false,
+    subtests: false,
     skipWithoutBody: false,
     skipNotes: false,
-    thisSkip: false,
+    thisMethods: new Set(),
     todoWithoutBody: false,
     states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
     playwright: false,
@@ -81,6 +91,7 @@ const vitest = {
         ['suite', DESCRIBE],
         ['beforeEach', HOOK],
     ]),
+    moduleIsDefault: false,
     globals: new Map([
         ['describe', DESCRIBE],
         ['suite', DESCRIBE],
@@ -102,12 +113,16 @@ const vitest = {
         ['todo', 'todo'],
         ['fails', 'fail'],
     ]),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
     tagKey: 'tags',
     plainTags: true,
     info: { param: 0, methods: new Set(['skip']) },
+    subtests: false,
     skipWithoutBody: true,
     skipNotes: true,
-    thisSkip: false,
+    thisMethods: new Set(),
     todoWithoutBody: false,
     states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
     playwright: false,
@@ -128,6 +143,7 @@ const MOCHA_EXPORTS = new Map([
 const mocha = {
     ownsModule: (source) => source === 'mocha',
     exports: MOCHA_EXPORTS,
+    moduleIsDefault: true,
     globals: new Map([
         ...[...MOCHA_EXPORTS].filter(([name]) => name !== 'it' && name !== 'test'),
         ['context', DESCRIBE],
@@ -141,16 +157,74 @@ const mocha = {
     effects: effects([['skip', 'skip']]),
     // Cypress's `{ browser: '!webkit' }` runs the test only in some browsers.
     optionEffects: new Map([['browser', 'skip']]),
+    anyOptionValue: false,
+    exclusiveStates: [],
+    optionalTitle: false,
     // @cypress/grep's `{ tags: '@smoke' }`, written with the `@`.
     tagKey: 'tags',
     plainTags: false,
+    subtests: false,
     skipWithoutBody: true,
     skipNotes: false,
-    thisSkip: true,
+    thisMethods: new Set(['skip']),
     todoWithoutBody: true,
     states: new Set(['skip', 'todo', 'new', 'quarantined']),
     playwright: false,
 };
+const NODE_TEST_MEMBERS = new Set(['only', 'skip', 'todo', 'expectFailure']);
+/** What a test's context can do to it, as `t.skip()`, or as `this.skip()` in a `function`. */
+const NODE_TEST_CONTEXT = new Set(['skip', 'todo']);
+/**
+ * Node's built-in runner. `test` and `it` are one function, as are `describe` and `suite`, and the state
+ * members are exported by name too. Only `beforeEach` and `afterEach` get the test's context, as a test
+ * does: as their first parameter, and as `this` when written as a `function`. `before`, `after` and the
+ * describe itself get the suite's, which can't skip.
+ */
+const nodeTest = {
+    name: 'node-test',
+    ownsModule: (source) => source === 'node:test',
+    exports: new Map([
+        ['test', TEST],
+        ['it', TEST],
+        ['describe', DESCRIBE],
+        ['suite', DESCRIBE],
+        ...[...NODE_TEST_MEMBERS].map((member) => [member, { kind: 'test', modifiers: [member] }]),
+        ['before', { kind: 'hook', modifiers: [], noContext: true }],
+        ['after', { kind: 'hook', modifiers: [], noContext: true }],
+        ['beforeEach', HOOK],
+        ['afterEach', HOOK],
+    ]),
+    defaultExport: TEST,
+    moduleIsDefault: true,
+    globals: new Map(),
+    testFunctions: ['test', 'it'],
+    testMembers: NODE_TEST_MEMBERS,
+    describeMembers: NODE_TEST_MEMBERS,
+    factories: new Set(),
+    effects: effects([
+        ['skip', 'skip'],
+        ['todo', 'todo'],
+        ['expectFailure', 'fail'],
+    ]),
+    optionEffects: new Map([
+        ['skip', 'skip'],
+        ['todo', 'todo'],
+        ['expectFailure', 'fail'],
+    ]),
+    anyOptionValue: true,
+    exclusiveStates: ['skip', 'todo', 'fail'],
+    optionalTitle: true,
+    plainTags: false,
+    info: { param: 0, methods: NODE_TEST_CONTEXT },
+    subtests: true,
+    skipWithoutBody: true,
+    // `t.skip('why')` takes a message, not a condition.
+    skipNotes: true,
+    thisMethods: NODE_TEST_CONTEXT,
+    todoWithoutBody: false,
+    states: new Set(['skip', 'todo', 'fail', 'new', 'quarantined']),
+    playwright: false,
+};
 export const FRAMEWORKS = {
     playwright,
     jest,
@@ -158,6 +232,7 @@ export const FRAMEWORKS = {
     mocha: { name: 'mocha', ...mocha },
     cypress: { name: 'cypress', ...mocha },
     webdriverio: { name: 'webdriverio', ...mocha },
+    'node-test': nodeTest,
 };
 /** Whether `source` belongs to a test runner other than `framework`, so its names are never tests here. */
 export function isOtherRunner(framework, source) {

package/dist/utils/options.d.ts

@@ -21,7 +21,7 @@ export interface CustomState {
 export interface GovernanceOptions {
     /**
      * The test framework of the files the config applies to: `'playwright'`, `'jest'`, `'vitest'`, `'mocha'`,
-     * `'cypress'` or `'webdriverio'`. Required; each framework's config, such as `configs.mocha`, sets it.
+     * `'cypress'`, `'webdriverio'` or `'node-test'`. Required; each framework's config, such as `configs.mocha`, sets it.
      */
     framework: FrameworkName;
     /**

package/dist/utils/schema.js

@@ -6,7 +6,9 @@ const KEY_PATTERN = '^[A-Z][A-Z0-9_]+$';
 const KEY_HINT = 'an uppercase key as it appears in tickets, such as WEB for WEB-123';
 /** `['"a"', '"b"', '"c"']` as `"a", "b" or "c"`. */
 const orList = (items) => `${items.slice(0, -1).join(', ')} or ${items.slice(-1).join('')}`;
-const FRAMEWORK_HINT = `set it to ${orList(FRAMEWORK_NAMES.map((name) => `"${name}"`))}, or use ${orList(FRAMEWORK_NAMES.map((name) => `configs.${name}`))}`;
+/** How code reads a framework's config: `configs.mocha`, or `configs['node-test']` for a name with a dash. */
+const configAccess = (name) => (/^\w+$/.test(name) ? `configs.${name}` : `configs['${name}']`);
+const FRAMEWORK_HINT = `set it to ${orList(FRAMEWORK_NAMES.map((name) => `"${name}"`))}, or use ${orList(FRAMEWORK_NAMES.map(configAccess))}`;
 const ticketSpecSchema = {
     type: 'object',
     properties: {

package/docs/rules/marker-matches-state.md

@@ -2,7 +2,7 @@
 
 📝 Require the marker keyword to match the test's state.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 

package/docs/rules/no-conflicting-states.md

@@ -2,7 +2,7 @@
 
 📝 Disallow state tags that contradict each other, differ in case or look like typos.
 
-⚠️ This rule _warns_ in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+⚠️ This rule _warns_ in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 🔧 This rule is automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
 

package/docs/rules/no-orphaned-marker.md

@@ -2,7 +2,7 @@
 
 📝 Disallow marker comments that no longer match a test state.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 

package/docs/rules/require-ticket-in-comments.md

@@ -2,7 +2,7 @@
 
 📝 Require FIXME and TODO comments in test files to start with a ticket.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
@@ -32,7 +32,8 @@ How comments are read:
   rejected, and no text after the tickets unless `allowNotes` is set.
 - A `// FIXME:` marker directly above a `test.fixme(...)`, or a `// TODO:` marker above a todo test,
   such as Jest's `test.todo(...)` or Mocha's `it('title')`, is checked by [`require-ticket`](require-ticket.md) instead, so it is
-  reported once.
+  reported once. That includes one in the wrong case, `// fixme:` or `// Todo:`, which `require-ticket` asks to write in
+  uppercase.
 - Only test files (a test framework import or a call to a test function) are checked.
   Application code is left alone, even if your config applies the plugin to it.
 

package/docs/rules/require-ticket.md

@@ -2,7 +2,7 @@
 
 📝 Require a ticket marker comment above skipped, fixme and tagged tests.
 
-💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
+💼 This rule is enabled in the following [configs](https://github.com/Huldoser/eslint-plugin-test-governance#usage): 🌲 `cypress`, 🃏 `jest`, ☕ `mocha`, 🟢 `node-test`, 🎭 `playwright`, ⚡ `vitest`, 🤖 `webdriverio`.
 
 💡 This rule is manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
@@ -17,7 +17,7 @@ A test is in a state when it is:
 | -------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | -------------------------- |
 | `skip`         | `test.skip('title', fn)`, `test.describe.skip`, `test.skip()` in a body, `testInfo.skip()`, `test.step.skip`, `step.skip()` in a step | `// SKIP:`             | yes                        |
 | `fixme`        | `test.fixme(...)`, `test.describe.fixme`, `testInfo.fixme()`                                                                          | `// FIXME:`            | yes                        |
-| `todo`         | Jest's and Vitest's `test.todo`, and a Mocha test with only a title, `it('title')`                                                    | `// TODO:`             | yes, except in Playwright  |
+| `todo`         | Jest's, Vitest's and `node:test`'s `test.todo`, and a Mocha test with only a title, `it('title')`                                     | `// TODO:`             | yes, except in Playwright  |
 | `new`          | the `@new` tag                                                                                                                        | `// NEW:`              | with `lifecycleTags: true` |
 | `quarantined`  | the `@quarantined` tag                                                                                                                | `// QUARANTINED:`      | with `lifecycleTags: true` |
 | `fail`, `slow` | `test.fail(...)`, `test.slow()`, `testInfo.fail()`, `testInfo.slow()`                                                                 | `// FAIL:`, `// SLOW:` | no                         |
@@ -26,7 +26,9 @@ A test is in a state when it is:
 In Jest and Vitest, `xit`, `xdescribe`, Vitest's `{ skip: true }`, `skipIf(true)`, `context.skip()` and
 `context.skip('note')`, in a test or in `beforeEach`, skip a test too, and `test.failing` and `test.fails` put it in the `fail` state. In Mocha, Cypress and WebdriverIO, `xit`, `xdescribe` and
 `this.skip()` in a test or hook skip a test too, and Cypress's `{ browser: '!webkit' }` skips it in other
-browsers, which counts as a conditional skip. The [README](../../README.md#frameworks) lists every form.
+browsers, which counts as a conditional skip. In `node:test`, `{ skip: 'reason' }`, `t.skip()` and `this.skip()` skip a test, `{ todo: true }`,
+`t.todo()` and `this.todo()` make it a todo, `t.test()` subtests count as tests, and `test.expectFailure` puts it in the `fail` state. The
+[README](../../README.md#frameworks) lists every form.
 
 Tags are read from the title (`'places a limit order @new'`) and from `{ tag: '@new' }` or `{ tag: ['@new', '@smoke'] }`,
 also when they come from a `const` or an enum declared in the same file, as in `{ tag: TAGS.NEW }`.
@@ -203,6 +205,14 @@ it('settles a trade at T+1', function () {
 });
 ```
 
+<!-- example: invalid settings={"framework":"node-test"} -->
+
+```js
+import { test } from 'node:test';
+
+test('liquidates below maintenance', { skip: 'broker sandbox is down' }, () => {});
+```
+
 <!-- example: invalid settings={"framework":"cypress","lifecycleTags":true} -->
 
 ```js
@@ -276,6 +286,19 @@ describe('settlement', function () {
 });
 ```
 
+<!-- example: valid settings={"framework":"node-test"} -->
+
+```js
+import { test } from 'node:test';
+
+// SKIP: TRADE-92
+test('liquidates below maintenance', { skip: 'broker sandbox is down' }, () => {});
+
+test('nets margin across accounts', (t) => {
+  if (!process.env.RISK_URL) t.skip();
+});
+```
+
 ## Options
 
 This rule has no options of its own. It reads the shared options described in the

package/docs/upgrading.md

@@ -90,7 +90,7 @@ becomes `extends: ['test-governance/playwright']`.
 A config that still reads `configs.recommended` fails when it loads:
 
 ```text
-eslint-plugin-test-governance: configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress or configs.webdriverio. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md
+eslint-plugin-test-governance: configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio or configs['node-test']. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md
 ```
 
 ### The framework option
@@ -121,7 +121,7 @@ Without it, the config fails when it loads:
 
 ```text
 eslint-plugin-test-governance: invalid options:
-  - framework is required: set it to "playwright", "jest", "vitest", "mocha", "cypress" or "webdriverio", or use configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress or configs.webdriverio
+  - framework is required: set it to "playwright", "jest", "vitest", "mocha", "cypress", "webdriverio" or "node-test", or use configs.playwright, configs.jest, configs.vitest, configs.mocha, configs.cypress, configs.webdriverio or configs['node-test']
 ```
 
 If you write `settings['test-governance']` yourself instead of calling `configure()`, add `framework`

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-test-governance",
-  "version": "0.7.0",
-  "description": "ESLint rules that require a ticket comment above skipped, fixme, todo and tagged Playwright, Jest, Vitest, Mocha, Cypress and WebdriverIO tests.",
+  "version": "0.8.1",
+  "description": "ESLint rules that require a ticket comment above skipped, fixme, todo and tagged Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO and node:test tests.",
   "keywords": [
     "eslint",
     "eslintplugin",
@@ -12,6 +12,7 @@
     "mocha",
     "cypress",
     "webdriverio",
+    "node-test",
     "testing"
   ],
   "homepage": "https://github.com/Huldoser/eslint-plugin-test-governance#readme",