eslint-plugin-test-governance 0.10.0 → 0.10.1

package/CHANGELOG.md

@@ -6,6 +6,26 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.10.1] - 2026-10-31
+
+### Fixed
+
+- Options that belong to another preset, such as `prefixes` on `trello`, are reported even when a value next
+  to them is malformed, so one run shows both the misplaced option and the bad value.
+- A placeholder with several `*` characters, such as `*a*a*a*a*b`, matches in one pass instead of
+  backtracking on a long ticket.
+- A details object written as a literal with a spread or a computed key, `{ ...base, tag: '@new' }` or
+  `{ ['tag']: '@new' }`, keeps its tags and options; a key or spread that can't be read, such as an object
+  imported from another file, is reported with `reportUnreadableTags` instead of being ignored.
+- A tag read from an array element, `TAGS[1]`, or from a constant inside a template, `` `${TAG}` ``, is
+  checked like the constant itself.
+- A runtime skip method kept in a local variable, `const { skip } = t`, `const s = testInfo.skip` or
+  `const p = pending`, is checked like the method called on the context, in every framework.
+- `node:test`'s `test.describe` and `test.it` are read after `import { test } from 'node:test'`, as they were
+  after `require()` or a default import. A state member kept in a variable, `const s = it.skip` or
+  `const { skip } = it`, is checked like `it.skip(...)` in every framework. The same holds for a skip called
+  on a required module used inline, `require('node:test').test.skip(...)`.
+
 ## [0.10.0] - 2026-10-30
 
 ### Added
@@ -396,7 +416,8 @@ 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.10.0...HEAD
+[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.10.1...HEAD
+[0.10.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.10.0...v0.10.1
 [0.10.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.8.1...v0.9.0
 [0.8.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.8.0...v0.8.1

package/dist/utils/analyze.js

@@ -30,6 +30,12 @@ function memberName(node) {
         return node.property.value;
     return undefined;
 }
+/** The key a member expression reads, including an array index as in `TAGS[1]`. */
+function memberKey(node) {
+    if (node.property.type === 'Literal' && typeof node.property.value === 'number')
+        return String(node.property.value);
+    return memberName(node);
+}
 /**
  * The name a callee starts from and the members after it: `['describe', 'skip']` for
  * `test.describe.skip`. A member called to build the function, as `each` in `test.each(table)` or
@@ -63,7 +69,7 @@ function chainOf(node, factories) {
             args.set(`${name}()`, current.arguments.at(0));
         current = factory.object;
     }
-    return current.type === 'Identifier' ? { root: current, path, args } : undefined;
+    return current.type === 'Identifier' || current.type === 'CallExpression' ? { root: current, path, args } : undefined;
 }
 function unwrap(node) {
     let current = node;
@@ -79,9 +85,11 @@ function isFunction(node) {
 }
 /** Collects the top-level names that refer to the framework's test functions or to its module. */
 function collectTestNames(program, framework, configured) {
+    /** The framework's `test` function, which is also its module when `moduleIsDefault`. */
+    const testRoot = framework.defaultExport ?? TEST;
     const roots = new Map(framework.globals);
     for (const name of configured)
-        roots.set(name, TEST);
+        roots.set(name, testRoot);
     const runtime = new Map();
     const modules = new Set();
     const mergeTests = new Set();
@@ -91,7 +99,23 @@ function collectTestNames(program, framework, configured) {
     const moduleMember = (node) => node.type === 'MemberExpression' && node.object.type === 'Identifier' && modules.has(node.object.name)
         ? memberName(node)
         : undefined;
-    /** The test function an expression is, such as `base.extend({...})` or `mergeTests(a, b)`. */
+    /**
+     * What a member of a test function is: `it.skip` is `it` in the skip state, and node:test's
+     * `test.describe` is the `describe` export, since its module is also its `test`.
+     */
+    const memberRoot = (object, name) => {
+        if (framework.defaultExport !== undefined && object === framework.defaultExport) {
+            const exported = framework.exports.get(name);
+            if (exported !== undefined)
+                return exported;
+        }
+        const effect = framework.effects.get(name);
+        if (effect !== undefined && effect.when === undefined) {
+            return { kind: object.kind, modifiers: [...object.modifiers, effect.modifier] };
+        }
+        return undefined;
+    };
+    /** The test function an expression is, such as `base.extend({...})`, `mergeTests(a, b)` or `it.skip`. */
     const resolve = (node) => {
         const target = unwrap(node);
         if (target.type === 'Identifier')
@@ -99,15 +123,20 @@ function collectTestNames(program, framework, configured) {
         const member = moduleMember(target);
         if (member !== undefined)
             return framework.exports.get(member);
+        if (target.type === 'MemberExpression') {
+            const object = resolve(target.object);
+            const name = memberName(target);
+            return object === undefined || name === undefined ? undefined : memberRoot(object, name);
+        }
         if (target.type !== 'CallExpression')
             return undefined;
         // mergeTests(dbTest, a11yTest) or pw.mergeTests(dbTest, a11yTest)
         if (target.callee.type === 'Identifier')
-            return mergeTests.has(target.callee.name) ? TEST : undefined;
+            return mergeTests.has(target.callee.name) ? testRoot : undefined;
         if (target.callee.type !== 'MemberExpression')
             return undefined;
         if (moduleMember(target.callee) === 'mergeTests')
-            return TEST;
+            return testRoot;
         return memberName(target.callee) === 'extend' ? resolve(target.callee.object) : undefined;
     };
     // require('node:test'), ava, ava.serial or `ava as TestFn<Context>`
@@ -189,12 +218,18 @@ function collectTestNames(program, framework, configured) {
                 }
             }
             else if (declarator.id.type === 'ObjectPattern') {
-                // Playwright's `const { describe } = test`, used as `describe.skip(...)`.
-                if (framework.playwright && resolve(init)) {
+                // `const { describe } = test` and `const { skip } = it`, used as `describe.skip(...)`.
+                const base = resolve(init);
+                if (base !== undefined) {
                     for (const prop of declarator.id.properties) {
-                        if (prop.type === 'Property' && prop.value.type === 'Identifier' && propertyName(prop) === 'describe') {
-                            roots.set(prop.value.name, DESCRIBE);
-                        }
+                        if (prop.type !== 'Property' || prop.value.type !== 'Identifier')
+                            continue;
+                        const name = propertyName(prop);
+                        if (name === undefined)
+                            continue;
+                        const root = name === 'describe' && framework.playwright ? DESCRIBE : memberRoot(base, name);
+                        if (root)
+                            roots.set(prop.value.name, root);
                     }
                     continue;
                 }
@@ -249,6 +284,15 @@ function declaredWhere(sourceCode, id) {
     }
     return 'global';
 }
+/** The variable a name resolves to, walking out through the enclosing scopes. */
+function declaredVariable(sourceCode, id) {
+    for (let scope = sourceCode.getScope(id); scope; scope = scope.upper) {
+        const variable = scope.set.get(id.name);
+        if (variable)
+            return variable;
+    }
+    return undefined;
+}
 /**
  * Whether `id` refers to a variable or function declared inside a function or block, such as a local
  * helper that happens to be called `test`. Top-level variables, imports, parameters and globals still count.
@@ -434,13 +478,20 @@ function constantValue(sourceCode, node) {
         return declaredValue(sourceCode, node);
     if (node.type !== 'MemberExpression')
         return undefined;
-    const key = memberName(node);
+    const key = memberKey(node);
     const value = constantValue(sourceCode, unwrap(node.object));
     const owner = value && unwrap(value);
     if (key === undefined || owner === undefined)
         return undefined;
     if (owner.type === 'ObjectExpression')
         return propertyValue(owner, key);
+    if (owner.type === 'ArrayExpression') {
+        const index = Number(key);
+        if (!Number.isInteger(index))
+            return undefined;
+        const element = owner.elements[index];
+        return element !== null && element.type !== 'SpreadElement' ? element : undefined;
+    }
     if (owner.type !== 'TSEnumDeclaration')
         return undefined;
     const member = owner.body.members.find((m) => (m.id.type === 'Identifier' ? m.id.name : m.id.value) === key);
@@ -455,6 +506,15 @@ function readTexts(sourceCode, node, out, via, path = []) {
     const target = unwrap(node);
     if (isStaticText(target)) {
         out.texts.push({ text: target, via });
+        // A template that holds a constant, as in `` `${TAG}` ``, reads the constant's text too.
+        if (target.type === 'TemplateLiteral') {
+            for (const expression of target.expressions) {
+                const value = constantValue(sourceCode, unwrap(expression));
+                const resolved = value && unwrap(value);
+                if (resolved !== undefined && isStaticText(resolved))
+                    out.texts.push({ text: resolved, via });
+            }
+        }
         return;
     }
     if (target.type === 'ArrayExpression') {
@@ -471,6 +531,45 @@ function readTexts(sourceCode, node, out, via, path = []) {
     else
         readTexts(sourceCode, value, out, via ?? target, [...path, value]);
 }
+/**
+ * The key of a details property, following a computed string key declared in this file. A computed key that
+ * can't be read, as in `{ [key]: '@new' }`, goes in `unread`, since it may be the tag or an option.
+ */
+function detailKey(sourceCode, prop, unread) {
+    const key = unwrap(prop.key);
+    if (!prop.computed) {
+        return key.type === 'Identifier' ? key.name : String(key.value);
+    }
+    if (key.type === 'Literal' && typeof key.value === 'string')
+        return key.value;
+    if (key.type === 'TemplateLiteral' && key.expressions.length === 0)
+        return key.quasis[0]?.value.cooked ?? undefined;
+    const value = constantValue(sourceCode, key);
+    const resolved = value && unwrap(value);
+    if (resolved?.type === 'Literal' && typeof resolved.value === 'string')
+        return resolved.value;
+    unread.push(prop.key);
+    return undefined;
+}
+/**
+ * The plain-keyed properties of a details object, following spread objects declared in this file and
+ * collecting the ones that can't be read.
+ */
+function objectDetails(sourceCode, object, unread) {
+    return object.properties.flatMap((prop) => {
+        if (prop.type === 'SpreadElement') {
+            const argument = unwrap(prop.argument);
+            const value = argument.type === 'ObjectExpression' ? argument : constantValue(sourceCode, argument);
+            const spread = value && unwrap(value);
+            if (spread?.type === 'ObjectExpression')
+                return objectDetails(sourceCode, spread, unread);
+            unread.push(prop.argument);
+            return [];
+        }
+        const key = detailKey(sourceCode, prop, unread);
+        return key === undefined ? [] : [[key, prop.value]];
+    });
+}
 /**
  * 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
@@ -479,7 +578,7 @@ function readTexts(sourceCode, node, out, via, path = []) {
 function detailsOf(sourceCode, call, optionsFirst) {
     const details = call.arguments.at(optionsFirst ? 0 : 1);
     if (details === undefined || isFunction(details))
-        return { entries: [] };
+        return { entries: [], unread: [] };
     const target = unwrap(details);
     const value = target.type === 'ObjectExpression' ? target : constantValue(sourceCode, target);
     const object = value && unwrap(value);
@@ -487,16 +586,11 @@ function detailsOf(sourceCode, call, optionsFirst) {
         // 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(optionsFirst ? 1 : 2).some(isFunction)
-            ? { entries: [], unread: details }
-            : { entries: [] };
+            ? { entries: [], unread: [details] }
+            : { entries: [], unread: [] };
     }
-    const entries = object.properties.flatMap((prop) => {
-        if (prop.type !== 'Property' || prop.computed)
-            return [];
-        const key = prop.key.type === 'Identifier' ? prop.key.name : String(prop.key.value);
-        return [[key, prop.value]];
-    });
-    return { entries };
+    const unread = [];
+    return { entries: objectDetails(sourceCode, object, unread), unread };
 }
 const NO_TAGS = { tags: [], dynamic: false, unread: [], opaqueDetails: false };
 function collectTags(sourceCode, call, hasTitle, framework, details) {
@@ -521,9 +615,9 @@ function collectTags(sourceCode, call, hasTitle, framework, details) {
             scanTags(source, found, tags);
     }
     const unread = [...values.unread];
-    if (details.unread && framework.tagKey !== undefined)
-        unread.push(details.unread);
-    return { tags, dynamic: title.unread.size > 0, unread, opaqueDetails: details.unread !== undefined };
+    if (details.unread.length > 0 && framework.tagKey !== undefined)
+        unread.push(...details.unread);
+    return { tags, dynamic: title.unread.size > 0, unread, opaqueDetails: details.unread.length > 0 };
 }
 /** Whether `node` is an object written out or held in a constant declared in this file. */
 function isObject(sourceCode, node) {
@@ -695,10 +789,20 @@ function runAnalysis(sourceCode, options) {
         if (chain === undefined)
             return undefined;
         const { root, path, args } = chain;
+        // `require('node:test').test.skip(...)`: the require call stands for the module, with its exports.
+        if (root.type !== 'Identifier') {
+            const source = requireSource(root);
+            if (source === undefined || !framework.ownsModule(source) || path.length === 0)
+                return undefined;
+            const exported = framework.exports.get(path[0]);
+            return exported === undefined ? undefined : { root: exported, path: path.slice(1), args };
+        }
         let base = testNames.roots.get(root.name);
         let rest = path;
-        // `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;
+        // `pw.test.skip`, or node:test's `test.describe`, whose module is also its `test` even when
+        // `test` was imported by name.
+        const moduleLike = testNames.modules.has(root.name) || (framework.defaultExport !== undefined && base === framework.defaultExport);
+        const member = moduleLike ? framework.exports.get(path[0]) : undefined;
         if (member !== undefined || base === undefined) {
             base = member;
             rest = path.slice(1);
@@ -989,8 +1093,60 @@ function runAnalysis(sourceCode, options) {
         const { callee } = call;
         // The innermost parameter with a name is the one the call uses.
         const innermost = (name) => infos.findLast((info) => info.name === name);
+        /**
+         * What a name stands for: a context in scope, or a local constant that keeps one of its methods, as
+         * `const skip = testInfo.skip`, `const { skip } = t` or `const p = pending`.
+         */
+        const resolveInfo = (id) => {
+            const direct = innermost(id.name);
+            if (direct !== undefined)
+                return direct;
+            const definition = declaredVariable(sourceCode, id)?.defs.find((def) => def.type === 'Variable');
+            const declarator = definition?.node;
+            if (declarator?.type !== 'VariableDeclarator' || declarator.init === null)
+                return undefined;
+            const init = unwrap(declarator.init);
+            if (declarator.id.type === 'Identifier') {
+                if (init.type === 'MemberExpression') {
+                    const name = memberName(init);
+                    if (name === undefined)
+                        return undefined;
+                    if (init.object.type === 'ThisExpression') {
+                        const owner = thisFunction(declarator);
+                        return owner !== undefined && thisBodies.has(owner) && framework.thisMethods.has(name)
+                            ? { name: id.name, method: name }
+                            : undefined;
+                    }
+                    const object = init.object.type === 'Identifier' ? innermost(init.object.name) : undefined;
+                    return object?.methods?.has(name) ? { name: id.name, method: name, step: object.step } : undefined;
+                }
+                if (init.type !== 'Identifier')
+                    return undefined;
+                const source = innermost(init.name);
+                if (source === undefined)
+                    return undefined;
+                const fn = source.runtimeFunction;
+                if (fn && declaredWhere(sourceCode, init) !== (fn.imported ? 'top' : 'global'))
+                    return undefined;
+                if (source.method !== undefined)
+                    return { name: id.name, method: source.method, step: source.step };
+                return { name: id.name, methods: source.methods, step: source.step };
+            }
+            if (declarator.id.type !== 'ObjectPattern' || init.type !== 'Identifier')
+                return undefined;
+            const source = innermost(init.name);
+            if (source?.methods === undefined)
+                return undefined;
+            const property = declarator.id.properties.find((prop) => prop.type === 'Property' && prop.value.type === 'Identifier' && prop.value.name === id.name);
+            if (property?.type !== 'Property')
+                return undefined;
+            const name = propertyName(property);
+            return name !== undefined && source.methods.has(name)
+                ? { name: id.name, method: name, step: source.step }
+                : undefined;
+        };
         if (callee.type === 'Identifier') {
-            const info = innermost(callee.name);
+            const info = resolveInfo(callee);
             if (info?.method === undefined)
                 return undefined;
             // A global such as Jasmine's `pending` counts unless the file declares the name itself; an import of
@@ -1016,7 +1172,7 @@ function runAnalysis(sourceCode, options) {
             return owner !== undefined && thisBodies.has(owner) ? runtimeSubject(call, name) : undefined;
         }
         if (object.type === 'Identifier') {
-            const info = innermost(object.name);
+            const info = resolveInfo(object);
             return info?.methods?.has(name) ? runtimeSubject(call, name, info.step) : undefined;
         }
         const isTestInfo = RUNTIME_MODIFIERS.has(name) &&

package/dist/utils/options.js

@@ -67,15 +67,15 @@ const STRICT_HOST_PRESETS = new Set(['notion', 'redmine', 'youtrack']);
 /** Option values the schema allows for every preset but this one can't use. */
 function ownOptionProblems(spec, at) {
     const problems = [];
-    if (spec.preset === 'jira') {
-        for (const [i, key] of (spec.projects ?? []).entries()) {
-            if (!/^[A-Z][A-Z0-9_]+$/.test(key)) {
+    if (spec.preset === 'jira' && Array.isArray(spec.projects)) {
+        for (const [i, key] of spec.projects.entries()) {
+            if (typeof key !== 'string' || !/^[A-Z][A-Z0-9_]+$/.test(key)) {
                 problems.push(`${at}.projects[${i}] must start with a letter and have at least two characters, as Jira keys do (got "${key}")`);
             }
         }
     }
     const { host } = spec;
-    if (STRICT_HOST_PRESETS.has(spec.preset) && host !== undefined && !HOST_ENTRY_RE.test(host)) {
+    if (STRICT_HOST_PRESETS.has(spec.preset) && typeof host === 'string' && !HOST_ENTRY_RE.test(host)) {
         problems.push(`${at}.host must be a host name such as tracker.example.com or *.example.com, with no scheme, port or path (got "${host}")`);
     }
     if (spec.preset === 'url' && spec.hosts === undefined) {
@@ -83,41 +83,63 @@ function ownOptionProblems(spec, at) {
     }
     return problems;
 }
+/** A spec the cross-field checks can read: an object whose `preset` names one of the presets. */
+function isTicketSpec(spec) {
+    if (typeof spec !== 'object' || spec === null || Array.isArray(spec))
+        return false;
+    const { preset } = spec;
+    return typeof preset === 'string' && Object.hasOwn(PRESET_OPTIONS, preset);
+}
 /** Options set on a ticket spec that its preset ignores, such as `host` on the `any` preset. */
 function presetProblems(ticket, path) {
-    if (ticket === undefined)
+    if (!ticket)
         return [];
     const specs = Array.isArray(ticket) ? ticket : [ticket];
     return specs.flatMap((spec, index) => {
+        if (!isTicketSpec(spec))
+            return [];
         const at = Array.isArray(ticket) ? `${path}[${index}]` : path;
         const allowed = PRESET_OPTIONS[spec.preset];
         const misplaced = Object.keys(spec)
             .filter((key) => key !== 'preset' && spec[key] !== undefined && !allowed.includes(key))
-            .map((key) => {
+            .flatMap((key) => {
             const presets = Object.entries(PRESET_OPTIONS).filter(([, keys]) => keys.includes(key));
-            return `${at}.${key} is not an option of the "${spec.preset}" preset (it applies to ${presets.map(([name]) => `"${name}"`).join(', ')})`;
+            // An option no preset defines is a typo, which the schema already reports with a suggestion.
+            if (presets.length === 0)
+                return [];
+            return [
+                `${at}.${key} is not an option of the "${spec.preset}" preset (it applies to ${presets.map(([name]) => `"${name}"`).join(', ')})`,
+            ];
         });
         return [...misplaced, ...ownOptionProblems(spec, at)];
     });
 }
 /** Problems the schema can't express: options that belong to another preset, and reused state names. */
 function crossFieldProblems(options) {
+    // `options` comes from user settings, so at runtime it can be anything; the schema reports a non-object.
+    const raw = options;
+    if (typeof raw !== 'object' || raw === null)
+        return [];
     const problems = presetProblems(options.ticket, 'ticket');
     for (const [name, override] of Object.entries(options.states ?? {})) {
-        if (typeof override === 'object')
-            problems.push(...presetProblems(override.ticket, `states.${name}.ticket`));
+        const state = override;
+        if (typeof state === 'object' && state !== null) {
+            problems.push(...presetProblems(state.ticket, `states.${name}.ticket`));
+        }
     }
     for (const [name, custom] of Object.entries(options.customStates ?? {})) {
         if (BUILTIN_STATE_NAMES.includes(name)) {
             problems.push(`customStates.${name} reuses the name of the built-in "${name}" state; give it another name, or use states.${name} to change the built-in`);
         }
-        problems.push(...presetProblems(custom.ticket, `customStates.${name}.ticket`));
+        problems.push(...presetProblems(custom?.ticket, `customStates.${name}.ticket`));
     }
     return problems;
 }
 export function compileOptions(options) {
     const schemaProblems = validate(options, optionsSchema);
-    const problems = schemaProblems.length > 0 ? schemaProblems : crossFieldProblems(options);
+    // The cross-field problems come first: a misplaced option is worth knowing even when a value next to it is
+    // malformed, and both are about the same setting.
+    const problems = [...crossFieldProblems(options), ...schemaProblems];
     if (problems.length > 0) {
         throw new ConfigError(`invalid options:\n${problems.map((problem) => `  - ${problem}`).join('\n')}`);
     }

package/dist/utils/tickets.js

@@ -391,20 +391,46 @@ function compilePreset(spec) {
         }
     }
 }
-function globToRegExp(glob) {
-    const body = glob
-        .split('*')
-        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, '\\$&'))
-        .join('.*');
-    return new RegExp(`^${body}$`, 'i');
+/**
+ * Matches a `*` wildcard placeholder against a ticket, case-insensitively, in one pass. A regex with `.*` per
+ * star backtracks on a placeholder like `*a*a*a*a*b`, which a user can write by hand.
+ */
+function matchesGlob(glob, value) {
+    const pattern = glob.toLowerCase();
+    const text = value.toLowerCase();
+    let p = 0;
+    let t = 0;
+    let star = -1;
+    let mark = 0;
+    while (t < text.length) {
+        if (p < pattern.length && pattern[p] === text[t]) {
+            p += 1;
+            t += 1;
+        }
+        else if (p < pattern.length && pattern[p] === '*') {
+            star = p;
+            p += 1;
+            mark = t;
+        }
+        else if (star !== -1) {
+            mark += 1;
+            t = mark;
+            p = star + 1;
+        }
+        else {
+            return false;
+        }
+    }
+    while (p < pattern.length && pattern[p] === '*')
+        p += 1;
+    return p === pattern.length;
 }
 export function compileTicketSpec(specs, placeholders) {
     const presets = specs.map(compilePreset);
-    const placeholderRes = placeholders.map(globToRegExp);
     return {
         check(ticket) {
             const bare = ticket.replace(/^#/, '');
-            if (placeholderRes.some((re) => re.test(ticket) || re.test(bare)))
+            if (placeholders.some((glob) => matchesGlob(glob, ticket) || matchesGlob(glob, bare)))
                 return 'placeholder';
             for (const generic of [false, true]) {
                 const ids = presets.flatMap((preset) => Boolean(preset.generic) === generic ? (preset.find(ticket) ?? []) : []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-test-governance",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "ESLint rules that require a ticket comment above skipped, fixme, todo and tagged Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO, node:test and Jasmine tests.",
   "keywords": [
     "eslint",