eslint-plugin-test-governance 0.13.2 → 0.13.3

package/CHANGELOG.md

@@ -6,6 +6,52 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.13.3] - 2026-11-09
+
+### Fixed
+
+- Vitest conditional factories can clear an earlier skip in a modifier chain. Runtime context methods
+  retain their state through TypeScript wrappers on the receiver or method.
+- Mutation detection follows wrapped references and aliases, and recognizes writes through the global
+  `Object` and `Reflect` mutation methods without treating shadowed helpers as those built-ins.
+- Retry counts are read through local constants and object members, with effective properties after
+  spreads and overrides. Unread spreads remain possible retries unless every relevant count is known.
+- Commented-out tests no longer hide a broken marker or a disallowed note behind another valid marker.
+- Negative numeric and bigint template interpolations, `void`, and unshadowed `undefined`, `NaN` and
+  `Infinity` retain their rendered text when checking tag boundaries.
+- Mutable constant objects and arrays no longer supply stale tag or annotation values after detected
+  property writes, deletion, array mutation or writes through a local alias.
+- Runtime context methods keep their original test owner inside nested subtests. Vitest skip notes
+  supplied through constants remain unconditional skips.
+- Test callees retain their meaning through TypeScript assertions and type instantiations, sequence
+  expressions and defaulted local destructuring. Repeated conditional factories use the final condition.
+- Nested conditional returns and throws, and conditional loop breaks and continues, guard later runtime
+  skips. Jest retry calls are recognized through CommonJS object bindings and method aliases, including
+  bound arguments.
+- Primitive template interpolations retain their rendered text when checking tag boundaries. Object
+  prototype setters do not count as own tag or metadata properties, and suggestions use computed keys
+  for metadata named `__proto__`.
+- Test functions are read through aliases of whole modules, local destructuring, bound functions and
+  nested conditional selections. Reassigning an alias to a helper no longer leaves it treated as a test.
+- Runtime test contexts and their methods keep their meaning through chains of aliases, `bind()` and
+  default parameter values. Arguments supplied by `bind()` retain their condition and reason, and a
+  bound title no longer gives a diagnostic whose end is before its start.
+- A runtime skip in a conditional loop, or after a conditional early exit inside a nested block, is
+  read as conditional. A TypeScript assertion around a literal boolean keeps that boolean's meaning.
+- With the retry state on, Jest's retry calls are read through renamed and namespace imports, and a
+  Mocha describe chosen by a condition still supplies its suite context for `this.retries()`.
+- Chains of constants retain their tags, details and annotation tickets. An unread computed property
+  no longer leaves an earlier member of a tag object treated as certain.
+- Tags from literal and nested template interpolations are checked using the rendered text's boundaries,
+  so joining text around an `@` doesn't invent a state tag. Plain Vitest tags written as templates count
+  like quoted strings. Cyclic constant and template definitions remain unread instead of recursing.
+- `annotations.only` checks every supplied issue ticket, including an invalid one next to a valid one.
+- The commented-out-test rule recognizes renamed test imports.
+- Removing an orphaned marker removes its complete line with CR or Unicode line endings too.
+- A suggestion to add another state's marker no longer copies a ticket that state's format rejects.
+- Suggestions that move a ticket into annotations escape line breaks in the annotation type or key,
+  keeping the suggested JavaScript valid.
+
 ## [0.13.2] - 2026-11-08
 
 ### Fixed
@@ -598,7 +644,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.13.2...HEAD
+[Unreleased]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.13.3...HEAD
+[0.13.3]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.13.2...v0.13.3
 [0.13.2]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.13.1...v0.13.2
 [0.13.1]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.13.0...v0.13.1
 [0.13.0]: https://github.com/Huldoser/eslint-plugin-test-governance/compare/v0.12.1...v0.13.0

package/dist/rules/marker-matches-state.js

@@ -70,7 +70,10 @@ export default createRule({
                         state: state.name,
                         subject: subjectName,
                     },
-                    suggest: present.comment.type === 'Line' && tickets !== '' && directive?.kind !== 'eslint-disable-line'
+                    suggest: present.comment.type === 'Line' &&
+                        tickets !== '' &&
+                        present.tickets.every((ticket) => state.ticket.check(ticket.text) === 'ok') &&
+                        directive?.kind !== 'eslint-disable-line'
                         ? [
                             {
                                 messageId: 'addMarker',

package/dist/rules/require-ticket-for-commented-out-tests.js

@@ -32,9 +32,9 @@ export default createRule({
                 context.report({ loc, messageId: 'missingMarker', data });
                 continue;
             }
-            const valid = own.find((m) => m.tickets.length > 0 && m.tickets.every((t) => t.result === 'ok'));
-            if (valid) {
-                const { extra } = valid;
+            const broken = own.find((m) => m.tickets.length === 0 || m.tickets.some((t) => t.result !== 'ok'));
+            if (broken === undefined) {
+                const extra = own.find((marker) => marker.extra !== undefined)?.extra;
                 if (extra === undefined || options.allowNotes)
                     continue;
                 context.report({
@@ -51,7 +51,7 @@ export default createRule({
                 });
                 continue;
             }
-            const [marker] = own;
+            const marker = broken;
             const bad = marker.tickets.find((t) => t.result !== 'ok');
             if (bad === undefined) {
                 context.report({ loc: marker.comment.loc, messageId: 'missingTicket', data });

package/dist/rules/require-ticket.js

@@ -107,11 +107,6 @@ export default createRule({
                         reportReason(subject, state);
                     continue;
                 }
-                if (annotationOnly) {
-                    reportAnnotationOnly(subject, state, annotationOnly);
-                    continue;
-                }
-                const result = evaluate(subject, state);
                 // Annotations are checked whenever a ticket is needed, whatever the markers say.
                 for (const ticket of annotationTicketsOf(subject)) {
                     if (state.ticket.check(ticket.text) !== 'ok' && reportOnce(`annotation:${ticket.node.range[0]}`)) {
@@ -122,6 +117,11 @@ export default createRule({
                         });
                     }
                 }
+                if (annotationOnly) {
+                    reportAnnotationOnly(subject, state, annotationOnly);
+                    continue;
+                }
+                const result = evaluate(subject, state);
                 if (result.kind === 'missing' && hasAnnotationTicket(subject, state, options))
                     continue;
                 if (result.kind !== 'ok' &&

package/dist/utils/analyze.js

@@ -99,17 +99,19 @@ function disableRegions(comments, states) {
 }
 /** The names a parameter gives to runtime info: `testInfo`, or `skip` in `({ skip }) => ...`. */
 function infoNames(param, methods, step) {
-    if (param?.type === 'Identifier')
-        return [{ name: param.name, binding: param, methods, step }];
-    if (param?.type !== 'ObjectPattern')
+    const target = param?.type === 'AssignmentPattern' ? param.left : param;
+    if (target?.type === 'Identifier')
+        return [{ name: target.name, binding: target, methods, step }];
+    if (target?.type !== 'ObjectPattern')
         return [];
-    return param.properties.flatMap((prop) => {
-        if (prop.type !== 'Property' || prop.value.type !== 'Identifier')
+    return target.properties.flatMap((prop) => {
+        if (prop.type !== 'Property')
+            return [];
+        const value = prop.value.type === 'AssignmentPattern' ? prop.value.left : prop.value;
+        if (value.type !== 'Identifier')
             return [];
         const method = propertyName(prop);
-        return method !== undefined && methods.has(method)
-            ? [{ name: prop.value.name, binding: prop.value, method, step }]
-            : [];
+        return method !== undefined && methods.has(method) ? [{ name: value.name, binding: value, method, step }] : [];
     });
 }
 function memberName(node) {
@@ -133,14 +135,14 @@ function memberKey(node) {
 function chainOf(node, factories) {
     const path = [];
     const args = new Map();
-    let current = node;
+    let current = unwrap(node);
     for (;;) {
         if (current.type === 'MemberExpression') {
             const name = memberName(current);
             if (name === undefined)
                 return undefined;
             path.unshift(name);
-            current = current.object;
+            current = unwrap(current.object);
             continue;
         }
         const factory = current.type === 'CallExpression'
@@ -154,9 +156,9 @@ function chainOf(node, factories) {
         if (name === undefined || !factories.has(name))
             return undefined;
         path.unshift(`${name}()`);
-        if (current.type === 'CallExpression')
+        if (current.type === 'CallExpression' && !args.has(`${name}()`))
             args.set(`${name}()`, current.arguments.at(0));
-        current = factory.object;
+        current = unwrap(factory.object);
     }
     return current.type === 'Identifier' || current.type === 'CallExpression' ? { root: current, path, args } : undefined;
 }
@@ -164,8 +166,12 @@ function unwrap(node) {
     let current = node;
     while (current.type === 'TSAsExpression' ||
         current.type === 'TSNonNullExpression' ||
-        current.type === 'TSSatisfiesExpression') {
-        current = current.expression;
+        current.type === 'TSSatisfiesExpression' ||
+        current.type === 'TSTypeAssertion' ||
+        current.type === 'TSInstantiationExpression' ||
+        current.type === 'SequenceExpression') {
+        current =
+            current.type === 'SequenceExpression' ? current.expressions[current.expressions.length - 1] : current.expression;
     }
     return current;
 }
@@ -382,6 +388,67 @@ function declaredVariable(sourceCode, id) {
     }
     return undefined;
 }
+const reassignedBindings = new WeakMap();
+/** Whether the binding has writes beyond its initial declaration. */
+function isReassigned(sourceCode, id) {
+    const variable = declaredVariable(sourceCode, id);
+    if (variable === undefined)
+        return false;
+    const cached = reassignedBindings.get(variable);
+    if (cached !== undefined)
+        return cached;
+    const written = variable.references.some((reference) => reference.isWrite() && !reference.init);
+    reassignedBindings.set(variable, written);
+    return written;
+}
+const mutatedBindings = new WeakMap();
+const ARRAY_MUTATORS = new Set(['copyWithin', 'fill', 'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift']);
+const OBJECT_MUTATORS = new Set(['assign', 'defineProperty', 'defineProperties']);
+const REFLECT_MUTATORS = new Set(['set', 'deleteProperty', 'defineProperty']);
+/** Whether a binding's object is written through a property, an array mutator or a local alias. */
+function isMutated(sourceCode, id, seen = []) {
+    const variable = declaredVariable(sourceCode, id);
+    if (variable === undefined || seen.includes(variable))
+        return false;
+    const cached = mutatedBindings.get(variable);
+    if (cached !== undefined)
+        return cached;
+    const written = variable.references.some((reference) => {
+        let value = reference.identifier;
+        let parent = value.parent;
+        while (parent.type !== 'Program' &&
+            ((parent.type === 'MemberExpression' && parent.object === value) || unwrap(parent) === value)) {
+            value = parent;
+            parent = value.parent;
+        }
+        if (parent.type === 'VariableDeclarator' && parent.init === value && parent.id.type === 'Identifier') {
+            return isMutated(sourceCode, parent.id, [...seen, variable]);
+        }
+        if (parent.type === 'CallExpression' && parent.arguments[0] === value) {
+            const callee = unwrap(parent.callee);
+            if (callee.type === 'MemberExpression' &&
+                callee.object.type === 'Identifier' &&
+                declaredWhere(sourceCode, callee.object) === 'global') {
+                const methods = callee.object.name === 'Object'
+                    ? OBJECT_MUTATORS
+                    : callee.object.name === 'Reflect'
+                        ? REFLECT_MUTATORS
+                        : undefined;
+                if (methods?.has(memberName(callee) ?? ''))
+                    return true;
+            }
+        }
+        const member = unwrap(value);
+        if (member.type !== 'MemberExpression')
+            return false;
+        return ((parent.type === 'AssignmentExpression' && parent.left === value) ||
+            parent.type === 'UpdateExpression' ||
+            (parent.type === 'UnaryExpression' && parent.operator === 'delete') ||
+            (parent.type === 'CallExpression' && parent.callee === value && ARRAY_MUTATORS.has(memberName(member) ?? '')));
+    });
+    mutatedBindings.set(variable, written);
+    return written;
+}
 /**
  * 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.
@@ -551,33 +618,66 @@ function parseMarkers(comment, states) {
     }
     return markers;
 }
-function scanTags(source, { text: node, via }, out) {
+/** Rendered template text and the offsets of its alternating literal and expression parts. */
+function templateText(sourceCode, node) {
+    const parts = node.quasis.flatMap((quasi, i) => [
+        // `cooked` is null only in tagged templates, which are not read as title or tag text.
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see above
+        quasi.value.cooked,
+        ...(i < node.expressions.length ? [interpolationText(sourceCode, node.expressions[i]) ?? ' '] : []),
+    ]);
+    let offset = 0;
+    const offsets = parts.map((part) => {
+        const start = offset;
+        offset += part.length;
+        return start;
+    });
+    return { parts, text: parts.join(''), offsets };
+}
+function scanTags(sourceCode, found, out) {
+    const { text: node, via, before = '', after = '' } = found;
+    const source = sourceCode.text;
     // Each piece of text with where it starts in the source, after its opening quote, backtick or `}`.
-    const parts = node.type === 'Literal'
-        ? [{ text: node.value, start: node.range[0] + 1 }]
-        : node.quasis.map((quasi) => ({
+    let parts;
+    if (node.type === 'Literal')
+        parts = [{ text: node.value, start: node.range[0] + 1, before, after }];
+    else {
+        const rendered = templateText(sourceCode, node);
+        parts = node.quasis.map((quasi, i) => ({
             // `cooked` is only null in tagged templates, which are never titles.
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see above
             text: quasi.value.cooked,
             start: quasi.range[0] + 1,
+            before: rendered.offsets[i * 2] === 0 ? before : rendered.text.charAt(rendered.offsets[i * 2] - 1),
+            after: rendered.text.slice(rendered.offsets[i * 2] + rendered.parts[i * 2].length) + after,
         }));
-    for (const { text, start } of parts) {
-        for (const match of text.matchAll(TAG_RE)) {
-            const end = match.index + match[0].length;
-            const written = via === undefined && source.slice(start, start + end) === text.slice(0, end);
-            out.push({ tag: match[0], node: via ?? node, ...(written && { range: [start + match.index, start + end] }) });
+    }
+    for (const { text, start, before, after } of parts) {
+        const prefix = before.slice(-1);
+        const tagStart = text.lastIndexOf('@');
+        const continuation = tagStart >= 0 && /^[\w-]*$/.test(text.slice(tagStart + 1)) ? (/^[\w-]+/.exec(after)?.[0] ?? '') : '';
+        for (const match of (prefix + text + continuation).matchAll(TAG_RE)) {
+            const index = match.index - prefix.length;
+            if (index < 0 || index >= text.length)
+                continue;
+            const end = index + match[0].length;
+            const written = via === undefined && end <= text.length && source.slice(start, start + end) === text.slice(0, end);
+            out.push({ tag: match[0], node: via ?? node, ...(written && { range: [start + index, start + end] }) });
         }
     }
 }
 const PLAIN_TAG_RE = /^[\w-]+$/;
 /** A Vitest tag name such as `'flaky'` in `tags`, which stands for the `@flaky` tag. */
-function plainTag(source, { text, via }) {
-    if (text.type !== 'Literal' || !PLAIN_TAG_RE.test(text.value))
+function plainTag(sourceCode, { text, via, embedded }) {
+    if (embedded)
+        return undefined;
+    const value = staticText(sourceCode, text);
+    if (value === undefined || !PLAIN_TAG_RE.test(value))
         return undefined;
     const start = text.range[0] + 1;
-    const end = start + text.value.length;
-    const written = via === undefined && source.slice(start, end) === text.value;
-    return { tag: `@${text.value}`, node: via ?? text, plain: true, ...(written && { range: [start, end] }) };
+    const end = start + value.length;
+    const written = via === undefined && sourceCode.text.slice(start, end) === value;
+    return { tag: `@${value}`, node: via ?? text, plain: true, ...(written && { range: [start, end] }) };
 }
 function isStaticText(node) {
     return (node.type === 'Literal' && typeof node.value === 'string') || node.type === 'TemplateLiteral';
@@ -587,6 +687,8 @@ function isStaticText(node) {
  * or the enum itself. Undefined for any other name, such as an import, a parameter or a `let`.
  */
 function declaredValue(sourceCode, id) {
+    if (isMutated(sourceCode, id))
+        return undefined;
     for (let scope = sourceCode.getScope(id); scope; scope = scope.upper) {
         const variable = scope.set.get(id.name);
         if (!variable)
@@ -602,13 +704,16 @@ function declaredValue(sourceCode, id) {
     }
     return undefined;
 }
+function isPrototypeSetter(prop) {
+    return (!prop.computed && !prop.shorthand && !prop.method && prop.kind === 'init' && propertyName(prop) === '__proto__');
+}
 /** The value of the last property called `key`, or undefined when a spread written after it may replace it. */
 function propertyValue(object, key) {
     for (let i = object.properties.length - 1; i >= 0; i--) {
         const prop = object.properties[i];
-        if (prop.type === 'SpreadElement')
+        if (prop.type === 'SpreadElement' || (prop.computed && propertyName(prop) === undefined))
             return undefined;
-        if (propertyName(prop) === key)
+        if (!isPrototypeSetter(prop) && propertyName(prop) === key)
             return prop.value;
     }
     return undefined;
@@ -618,18 +723,32 @@ function propertyValue(object, key) {
  * after `const NEW = '@new'`, or of `Tags.NEW` after `const Tags = { NEW: '@new' }` or
  * `enum Tags { NEW = '@new' }`.
  */
-function constantValue(sourceCode, node) {
+function constantValue(sourceCode, node, seen = []) {
+    if (seen.includes(node))
+        return undefined;
+    const path = [...seen, node];
+    const follow = (value) => {
+        if (value === undefined)
+            return undefined;
+        const target = unwrap(value);
+        return target.type === 'Identifier' || target.type === 'MemberExpression'
+            ? constantValue(sourceCode, target, path)
+            : target;
+    };
     if (node.type === 'Identifier')
-        return declaredValue(sourceCode, node);
+        return follow(declaredValue(sourceCode, node));
     if (node.type !== 'MemberExpression')
         return undefined;
     const key = memberKey(node);
-    const value = constantValue(sourceCode, unwrap(node.object));
+    const object = unwrap(node.object);
+    const value = object.type === 'ObjectExpression' || object.type === 'ArrayExpression'
+        ? object
+        : constantValue(sourceCode, object, path);
     const owner = value && unwrap(value);
     if (key === undefined || owner === undefined)
         return undefined;
     if (owner.type === 'ObjectExpression')
-        return propertyValue(owner, key);
+        return follow(propertyValue(owner, key));
     if (owner.type === 'ArrayExpression') {
         const index = Number(key);
         if (!Number.isInteger(index) || index < 0 || String(index) !== key)
@@ -637,29 +756,43 @@ function constantValue(sourceCode, node) {
         if (owner.elements.slice(0, index + 1).some((element) => element?.type === 'SpreadElement'))
             return undefined;
         const element = owner.elements.at(index);
-        return element !== undefined && element !== null && element.type !== 'SpreadElement' ? element : undefined;
+        return element !== undefined && element !== null && element.type !== 'SpreadElement' ? follow(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);
-    return member?.initializer;
+    return follow(member?.initializer);
 }
 /**
  * Reads the text a title or tag value is made of: strings, template literals and arrays of them,
  * following constants declared in this file. What can't be read, such as a name imported from another
  * file, goes in `unread`: the name the call uses, or the value itself.
  */
-function readTexts(sourceCode, node, out, via, path = []) {
+function readTexts(sourceCode, node, out, via, path = [], context = {}) {
     const target = unwrap(node);
+    if (path.includes(target)) {
+        out.unread.add(via ?? target);
+        return;
+    }
     if (isStaticText(target)) {
-        out.texts.push({ text: target, via });
+        out.texts.push({ text: target, via, ...context });
         // 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 rendered = templateText(sourceCode, target);
+            for (const [i, expression] of target.expressions.entries()) {
+                const own = unwrap(expression);
+                const value = isStaticText(own) ? own : constantValue(sourceCode, own);
                 const resolved = value && unwrap(value);
-                if (resolved !== undefined && isStaticText(resolved))
-                    out.texts.push({ text: resolved, via });
+                if (resolved !== undefined && isStaticText(resolved)) {
+                    readTexts(sourceCode, resolved, out, via, [...path, target], {
+                        before: rendered.offsets[i * 2 + 1] === 0
+                            ? (context.before ?? '')
+                            : rendered.text.charAt(rendered.offsets[i * 2 + 1] - 1),
+                        after: rendered.text.slice(rendered.offsets[i * 2 + 1] + rendered.parts[i * 2 + 1].length) +
+                            (context.after ?? ''),
+                        embedded: true,
+                    });
+                }
             }
         }
         return;
@@ -667,7 +800,7 @@ function readTexts(sourceCode, node, out, via, path = []) {
     if (target.type === 'ArrayExpression') {
         for (const item of target.elements) {
             if (item)
-                readTexts(sourceCode, item.type === 'SpreadElement' ? item.argument : item, out, via, path);
+                readTexts(sourceCode, item.type === 'SpreadElement' ? item.argument : item, out, via, [...path, target], context);
         }
         return;
     }
@@ -676,7 +809,7 @@ function readTexts(sourceCode, node, out, via, path = []) {
     if (value === undefined || path.includes(value))
         out.unread.add(via ?? target);
     else
-        readTexts(sourceCode, value, out, via ?? target, [...path, value]);
+        readTexts(sourceCode, value, out, via ?? target, [...path, target], context);
 }
 /**
  * The key of a details property, following a computed string key declared in this file. A computed key that
@@ -726,6 +859,8 @@ function objectDetails(sourceCode, object, unread, path = []) {
                 entries.set(key, value);
             continue;
         }
+        if (isPrototypeSetter(prop))
+            continue;
         const key = detailKey(sourceCode, prop, unread);
         if (key === undefined)
             entries.clear();
@@ -755,16 +890,22 @@ function detailsOf(sourceCode, call, optionsFirst) {
     const unread = [];
     return { entries: objectDetails(sourceCode, object, unread), unread };
 }
-/** The static text a value gives: a string literal, a template with no expressions, or one of those held in a constant declared in this file. */
-function staticText(sourceCode, node) {
+/** Static string text, including templates whose expressions resolve to strings in this file. */
+function staticText(sourceCode, node, seen = []) {
+    if (seen.includes(node))
+        return undefined;
+    const path = [...seen, node];
     const read = (value) => {
         if (value.type === 'Literal')
             return typeof value.value === 'string' ? value.value : undefined;
-        if (value.type !== 'TemplateLiteral' || value.expressions.length !== 0)
+        if (value.type !== 'TemplateLiteral')
+            return undefined;
+        const expressions = value.expressions.map((expression) => interpolationText(sourceCode, expression, path));
+        if (expressions.some((text) => text === undefined))
             return undefined;
         // `cooked` is only null in tagged templates, which no annotation value is.
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- see above
-        return value.quasis[0].value.cooked;
+        return value.quasis.map((quasi, i) => quasi.value.cooked + (expressions[i] ?? '')).join('');
     };
     const target = unwrap(node);
     const own = read(target);
@@ -773,6 +914,31 @@ function staticText(sourceCode, node) {
     const constant = constantValue(sourceCode, target);
     return constant === undefined ? undefined : read(unwrap(constant));
 }
+/** Static primitive interpolation text, without evaluating object coercion or user code. */
+function interpolationText(sourceCode, node, seen = []) {
+    const text = staticText(sourceCode, node, seen);
+    if (text !== undefined)
+        return text;
+    const target = unwrap(node);
+    const value = constantValue(sourceCode, target) ?? target;
+    if (value.type === 'Identifier' &&
+        declaredWhere(sourceCode, value) === 'global' &&
+        ['undefined', 'NaN', 'Infinity'].includes(value.name))
+        return value.name;
+    if (value.type === 'UnaryExpression') {
+        if (value.operator === 'void')
+            return 'undefined';
+        const argument = unwrap(value.argument);
+        if (value.operator === '-' &&
+            argument.type === 'Literal' &&
+            (typeof argument.value === 'number' || typeof argument.value === 'bigint'))
+            return String(-argument.value);
+    }
+    if (value.type !== 'Literal' ||
+        (value.value !== null && !['number', 'boolean', 'bigint'].includes(typeof value.value)))
+        return undefined;
+    return String(value.value);
+}
 /**
  * The object or array a details value is, following a constant declared in this file: a carrier for
  * annotations. Undefined for a value that plainly can't hold one, `'unread'` for one that can't be read.
@@ -887,25 +1053,24 @@ const NO_TAGS = {
     reasonedOptions: new Set(),
 };
 function collectTags(sourceCode, call, hasTitle, framework, details) {
-    const source = sourceCode.text;
     const tags = [];
     const title = { texts: [], unread: new Set() };
     // node:test's `test({ tags: ['db'] }, fn)` has no title, only options.
     if (hasTitle)
         readTexts(sourceCode, call.arguments[0], title);
     for (const found of title.texts)
-        scanTags(source, found, tags);
+        scanTags(sourceCode, found, tags);
     const values = { texts: [], unread: new Set() };
     for (const [key, value] of details.entries) {
         if (key === framework.tagKey)
             readTexts(sourceCode, value, values);
     }
     for (const found of values.texts) {
-        const plain = framework.plainTags ? plainTag(source, found) : undefined;
+        const plain = framework.plainTags ? plainTag(sourceCode, found) : undefined;
         if (plain)
             tags.push(plain);
         else
-            scanTags(source, found, tags);
+            scanTags(sourceCode, found, tags);
     }
     const unread = [...values.unread];
     if (details.unread.length > 0 && framework.tagKey !== undefined)
@@ -977,7 +1142,8 @@ function thisFunction(node) {
 }
 /** The value of a `true` or `false` literal; undefined for anything else. */
 function booleanOf(node) {
-    return node?.type === 'Literal' && typeof node.value === 'boolean' ? node.value : undefined;
+    const value = node === undefined ? undefined : unwrap(node);
+    return value?.type === 'Literal' && typeof value.value === 'boolean' ? value.value : undefined;
 }
 /**
  * Whether a node:test option applies: Node counts any value but `false` and `undefined`, so a reason such
@@ -994,23 +1160,31 @@ function optionApplies(node) {
 }
 /** Keys of a retry options object that hold a count: Vitest's `count`, Cypress's `runMode` and `openMode`. */
 const RETRY_COUNT_KEYS = new Set(['count', 'runMode', 'openMode']);
+const VITEST_RETRY_COUNT_KEYS = new Set(['count']);
+const CYPRESS_RETRY_COUNT_KEYS = new Set(['runMode', 'openMode']);
 /**
  * Whether a retry count gives retries: anything but `0`, `false`, `null` or `undefined` written out, since a
  * count known only when the tests run, as `process.env.CI ? 2 : 0`, retries where flaky tests hide. An
  * object retries unless every count it holds is one of those.
  */
-function retries(node) {
+function retries(sourceCode, node, keys = RETRY_COUNT_KEYS, seen = []) {
     if (node === undefined)
         return false;
-    const value = unwrap(node);
+    if (seen.includes(node))
+        return true;
+    const own = unwrap(node);
+    const value = constantValue(sourceCode, own) ?? own;
     if (value.type === 'Literal')
         return value.value !== 0 && value.value !== false && value.value !== null;
     if (value.type === 'Identifier')
         return value.name !== 'undefined';
     if (value.type !== 'ObjectExpression')
         return true;
-    const counts = value.properties.flatMap((prop) => prop.type === 'Property' && RETRY_COUNT_KEYS.has(propertyName(prop) ?? '') ? [prop.value] : []);
-    return counts.length === 0 || counts.some(retries);
+    const unread = [];
+    const counts = objectDetails(sourceCode, value, unread).filter(([key]) => keys.has(key));
+    if (unread.length > 0 && ![...keys].every((key) => counts.some(([name]) => name === key)))
+        return true;
+    return counts.length === 0 || counts.some(([, count]) => retries(sourceCode, count, keys, [...seen, node]));
 }
 /** Values that are never `false` or `undefined`. */
 const OPTION_VALUES = new Set([
@@ -1026,13 +1200,13 @@ const OPTION_VALUES = new Set([
  * 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.
  */
-function isUnconditional(call, framework) {
+function isUnconditional(sourceCode, call, framework) {
     const first = call.arguments.at(0);
     const always = first === undefined ||
         booleanOf(first) === true ||
         // node:test's `t.skip(message)` and Jasmine's `pending(message)` take no condition, so any argument is a note.
         framework.reasonArgument === 'only' ||
-        (framework.skipNotes && isStaticText(first));
+        (framework.skipNotes && (isStaticText(unwrap(first)) || staticText(sourceCode, first) !== undefined));
     return always && !isGuarded(call);
 }
 /**
@@ -1087,19 +1261,26 @@ function optionReason(sourceCode, node) {
     return isReasonText(sourceCode, value.consequent) || isReasonText(sourceCode, value.alternate);
 }
 const FUNCTIONS = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression']);
-/** Whether a statement always leaves the function or block: `return`, `throw`, or a block containing one. */
+/** Whether a statement can leave the enclosing body, without entering nested functions or loops. */
 function exits(statement) {
-    if (statement.type === 'ReturnStatement' || statement.type === 'ThrowStatement')
+    if (statement.type === 'ReturnStatement' ||
+        statement.type === 'ThrowStatement' ||
+        statement.type === 'BreakStatement' ||
+        statement.type === 'ContinueStatement')
         return true;
+    if (statement.type === 'IfStatement')
+        return exits(statement.consequent) || (statement.alternate !== null && exits(statement.alternate));
     return statement.type === 'BlockStatement' && statement.body.some(exits);
 }
 /** `if (ready) return;` or `if (!ok) { throw error; }`: code after it only runs on some paths. */
 function isEarlyExit(statement) {
+    if (statement.type === 'BlockStatement')
+        return statement.body.some(isEarlyExit);
     return (statement.type === 'IfStatement' &&
         (exits(statement.consequent) || (statement.alternate !== null && exits(statement.alternate))));
 }
 /**
- * Whether the call only runs on some paths of its function: under an `if`, a `switch` case, a ternary,
+ * Whether the call only runs on some paths of its function: under an `if`, a `switch` case, a ternary or a loop,
  * the right side of `&&`, `||` or `??`, in a `catch` block, after other code in a `try` block that has a
  * `catch`, or after an early exit such as `if (ready) return;`. `if (!enabled) test.skip()` is the same as `test.skip(!enabled)`, and
  * `catch { test.skip(true, 'service is down') }` only skips when the service is down.
@@ -1107,11 +1288,18 @@ function isEarlyExit(statement) {
 function isGuarded(call) {
     let child = call;
     for (let node = call.parent; node && !FUNCTIONS.has(node.type); child = node, node = node.parent) {
-        if ((node.type === 'IfStatement' || node.type === 'ConditionalExpression') && child !== node.test)
+        const same = (other) => child.range[0] === other.range[0] && child.range[1] === other.range[1];
+        if ((node.type === 'IfStatement' || node.type === 'ConditionalExpression') && !same(node.test))
+            return true;
+        if (node.type === 'SwitchCase' && (node.test === null || !same(node.test)))
             return true;
-        if (node.type === 'SwitchCase' && child !== node.test)
+        if (node.type === 'LogicalExpression' && same(node.right))
             return true;
-        if (node.type === 'LogicalExpression' && child === node.right)
+        if (((node.type === 'WhileStatement' || node.type === 'ForStatement') &&
+            node.test !== null &&
+            booleanOf(node.test) !== true &&
+            child === node.body) ||
+            ((node.type === 'ForInStatement' || node.type === 'ForOfStatement') && child === node.body))
             return true;
         if (node.type === 'CatchClause')
             return true;
@@ -1156,6 +1344,22 @@ export function analyze(sourceCode, options) {
 function runAnalysis(sourceCode, options) {
     const { states, framework } = options;
     const testNames = collectTestNames(sourceCode.ast, framework, options.testFunctions);
+    /** Whole-module imports or requires, including constant aliases of them. */
+    const moduleOf = (node, seen = []) => {
+        const value = unwrap(node);
+        if (seen.includes(value))
+            return false;
+        if (value.type === 'Identifier') {
+            if (isReassigned(sourceCode, value))
+                return false;
+            if (testNames.modules.has(value.name) && declaredWhere(sourceCode, value) === 'top')
+                return true;
+            const alias = declaredValue(sourceCode, value);
+            return alias !== undefined && moduleOf(alias, [...seen, value]);
+        }
+        const source = requireSource(value);
+        return source !== undefined && framework.ownsModule(source);
+    };
     /**
      * The test function a callee starts from and the members after it, such as `test` and
      * `['describe', 'skip']` for `test.describe.skip` or `pw.test.describe.skip`. Undefined when the callee
@@ -1173,11 +1377,13 @@ function runAnalysis(sourceCode, options) {
             const exported = framework.exports.get(path[0]);
             return exported === undefined ? undefined : { root: exported, path: path.slice(1), args };
         }
+        if (isReassigned(sourceCode, root))
+            return undefined;
         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` even when
         // `test` was imported by name.
-        const moduleLike = testNames.modules.has(root.name) || (framework.defaultExport !== undefined && base === framework.defaultExport);
+        const moduleLike = moduleOf(root) || (framework.defaultExport !== undefined && base === framework.defaultExport);
         const member = moduleLike ? framework.exports.get(path[0]) : undefined;
         if (member !== undefined || base === undefined) {
             base = member;
@@ -1185,6 +1391,28 @@ function runAnalysis(sourceCode, options) {
         }
         if (base !== undefined && !isLocalVariable(sourceCode, root))
             return { root: base, path: rest, args };
+        const definition = declaredVariable(sourceCode, root)?.defs.find((def) => def.type === 'Variable');
+        const declarator = definition?.node;
+        if (declarator?.type === 'VariableDeclarator' &&
+            declarator.id.type === 'ObjectPattern' &&
+            declarator.init !== null) {
+            if (seen.includes(declarator))
+                return undefined;
+            const property = declarator.id.properties.find((prop) => {
+                if (prop.type !== 'Property')
+                    return false;
+                const binding = prop.value.type === 'AssignmentPattern' ? prop.value.left : prop.value;
+                return binding.type === 'Identifier' && binding.name === root.name;
+            });
+            const key = property?.type === 'Property' ? propertyName(property) : undefined;
+            const init = chainOf(unwrap(declarator.init), framework.factories);
+            return key === undefined || init === undefined
+                ? undefined
+                : target({ ...init, path: [...init.path, key, ...path], args: new Map([...init.args, ...args]) }, [
+                    ...seen,
+                    declarator,
+                ]);
+        }
         const value = declaredValue(sourceCode, root);
         if (value === undefined || seen.includes(value))
             return undefined;
@@ -1197,6 +1425,7 @@ function runAnalysis(sourceCode, options) {
     const allComments = sourceCode.getAllComments();
     const commentedOut = findCommentedOutTests(sourceCode, allComments, new Set([
         ...options.testFunctions,
+        ...[...testNames.roots].flatMap(([name, root]) => (root.kind === 'hook' ? [] : [name])),
         ...[...framework.exports, ...framework.globals].flatMap(([name, root]) => (root.kind === 'hook' ? [] : [name])),
     ]), new Set([...framework.testMembers, ...framework.describeMembers, 'describe', 'step'].map((m) => m.replace('()', ''))), states);
     const comments = allComments.filter((comment) => !commentedOut.comments.has(comment));
@@ -1371,14 +1600,16 @@ function runAnalysis(sourceCode, options) {
             // `skipIf(true)` always skips and `skipIf(false)` never does, like `{ skip: true }` and `{ skip: false }`.
             const condition = booleanOf(args.get(member));
             if (condition === undefined)
-                add(effect.modifier, false);
+                modifiers.set(effect.modifier, false);
             else if (condition === effect.when)
-                add(effect.modifier, true);
+                modifiers.set(effect.modifier, true);
+            else
+                modifiers.delete(effect.modifier);
         }
         // `{ skip: true }` always skips, `{ skip: isMobile }` only sometimes, `{ skip: false }` never.
         for (const [key, value] of details) {
             if (key === framework.retryOption) {
-                if (retries(value))
+                if (retries(sourceCode, value, framework.name === 'vitest' ? VITEST_RETRY_COUNT_KEYS : CYPRESS_RETRY_COUNT_KEYS))
                     add('retry', true);
                 continue;
             }
@@ -1463,26 +1694,38 @@ function runAnalysis(sourceCode, options) {
         const callee = unwrap(picker);
         if (callee.type !== 'ConditionalExpression')
             return undefined;
-        const [yes, no] = [callee.consequent, callee.alternate].map((side) => {
-            const picked = target(chainOf(unwrap(side), framework.factories));
-            return picked && declarationOf(picked);
-        });
+        const choices = (node) => {
+            const value = unwrap(node);
+            if (value.type === 'ConditionalExpression') {
+                const yes = choices(value.consequent);
+                const no = choices(value.alternate);
+                return yes === undefined || no === undefined ? undefined : [...yes, ...no];
+            }
+            const picked = target(chainOf(value, framework.factories));
+            const declaration = picked && declarationOf(picked);
+            return declaration && [declaration];
+        };
+        const alternatives = choices(callee);
         const args = call.arguments;
-        if (yes === undefined || no === undefined)
+        if (alternatives === undefined)
             return undefined;
-        if (yes.kind !== no.kind || !declares(yes, args) || !declares(no, args))
+        const [first] = alternatives;
+        if (!alternatives.every((choice) => choice.kind === first.kind && declares(choice, args)))
             return undefined;
         usesTest = true;
         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')
+        const branches = alternatives.map(({ members, args: conditions }) => declarationModifiers(first.kind, args, modifiersOf(members, details.entries, conditions)));
+        if (first.kind === 'test')
             addThisBody(args);
+        const body = args.findLast(isFunction);
+        if (first.kind === 'describe' && body?.type === 'FunctionExpression')
+            suiteBodies.add(body);
         const modifiers = new Map();
-        for (const modifier of new Set([...ifYes.keys(), ...ifNo.keys()])) {
-            modifiers.set(modifier, ifYes.get(modifier) === true && ifNo.get(modifier) === true);
+        for (const modifier of new Set(branches.flatMap((branch) => [...branch.keys()]))) {
+            modifiers.set(modifier, branches.every((branch) => branch.get(modifier) === true));
         }
-        const infos = yes.kind === 'test' ? bodyInfos(args, yes.members) : [];
-        return { subject: makeSubject(yes.kind, call, modifiers, tagInfo), infos };
+        const infos = first.kind === 'test' ? bodyInfos(args, first.members) : [];
+        return { subject: makeSubject(first.kind, call, modifiers, tagInfo), infos };
     };
     /** The details, tags and annotations of a declaration; node:test lets it leave out its title. */
     const headOf = (call) => {
@@ -1516,13 +1759,65 @@ function runAnalysis(sourceCode, options) {
             suiteBodies.add(body);
         return { subject: makeSubject(kind, call, modifiers, tagInfo), infos };
     };
+    /** A context or runtime method, following stable local aliases and bound methods. */
+    const resolveInfo = (node, seen = []) => {
+        const value = unwrap(node);
+        if (seen.includes(value))
+            return undefined;
+        const path = [...seen, value];
+        if (value.type === 'CallExpression') {
+            const bind = unwrap(value.callee);
+            if (bind.type !== 'MemberExpression' || memberName(bind) !== 'bind')
+                return undefined;
+            const source = resolveInfo(bind.object, path);
+            return source?.method === undefined
+                ? undefined
+                : { ...source, boundArgs: [...(source.boundArgs ?? []), ...value.arguments.slice(1)] };
+        }
+        if (value.type === 'MemberExpression') {
+            const name = memberName(value);
+            if (name === undefined)
+                return undefined;
+            if (value.object.type === 'ThisExpression') {
+                const owner = thisFunction(value);
+                return owner !== undefined && thisBodies.has(owner) && framework.thisMethods.has(name)
+                    ? { name, method: name }
+                    : undefined;
+            }
+            const object = resolveInfo(value.object, path);
+            return object?.methods?.has(name) ? { name, method: name, step: object.step, owner: object.owner } : undefined;
+        }
+        if (value.type !== 'Identifier' || isReassigned(sourceCode, value))
+            return undefined;
+        const direct = infoOf(value);
+        if (direct !== undefined) {
+            const fn = direct.runtimeFunction;
+            return fn && declaredWhere(sourceCode, value) !== (fn.imported ? 'top' : 'global') ? undefined : direct;
+        }
+        const definition = declaredVariable(sourceCode, value)?.defs.find((def) => def.type === 'Variable');
+        const declarator = definition?.node;
+        if (declarator?.type !== 'VariableDeclarator' || declarator.init === null)
+            return undefined;
+        const source = resolveInfo(declarator.init, path);
+        if (source === undefined)
+            return undefined;
+        if (declarator.id.type === 'Identifier')
+            return { ...source, name: value.name, runtimeFunction: undefined };
+        if (declarator.id.type !== 'ObjectPattern' || source.methods === undefined)
+            return undefined;
+        const property = declarator.id.properties.find((prop) => prop.type === 'Property' && prop.value.type === 'Identifier' && prop.value.name === value.name);
+        const name = property?.type === 'Property' ? propertyName(property) : undefined;
+        return name !== undefined && source.methods.has(name)
+            ? { name: value.name, method: name, step: source.step, owner: source.owner }
+            : undefined;
+    };
     /** 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' || !infoOf(object)?.methods)
+        if (object.type !== 'Identifier' || !resolveInfo(object)?.methods)
             return undefined;
         const declaration = { kind: 'test', members: [], written: [], args: new Map() };
         return declares(declaration, call.arguments)
@@ -1569,11 +1864,16 @@ function runAnalysis(sourceCode, options) {
         return visited;
     };
     const visitDeclaredCall = (original, alias) => {
-        const call = throughFunctionMethods(original);
-        const written = alias ?? call.callee;
+        const normalized = throughFunctionMethods(original);
+        const expanded = alias === undefined
+            ? normalized
+            : throughFunctionMethods({ ...normalized, callee: alias });
+        const call = expanded.arguments === normalized.arguments ? normalized : { ...normalized, arguments: expanded.arguments };
+        const written = expanded.callee;
         const callee = target(chainOf(written, framework.factories));
         if (callee === undefined) {
-            return subtestOf(call) ?? pickedDeclaration(call, written) ?? { subject: runtimeCall(call) ?? retryCall(call) };
+            return (subtestOf(call) ??
+                pickedDeclaration(call, written) ?? { subject: runtimeCall(call) ?? retryCall({ ...call, callee: written }) });
         }
         usesTest = true;
         const args = call.arguments;
@@ -1621,88 +1921,21 @@ function runAnalysis(sourceCode, options) {
      */
     const runtimeCall = (call) => {
         const { callee } = call;
-        /**
-         * 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 = infoOf(id);
-            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' ? infoOf(init.object) : undefined;
-                    return object?.methods?.has(name) ? { name: id.name, method: name, step: object.step } : undefined;
-                }
-                if (init.type !== 'Identifier')
-                    return undefined;
-                const source = infoOf(init);
-                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 = infoOf(init);
-            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 = 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
-            // one counts unless a function or block declares the name again.
-            const fn = info.runtimeFunction;
-            if (fn && declaredWhere(sourceCode, callee) !== (fn.imported ? 'top' : 'global'))
-                return undefined;
-            const subject = runtimeSubject(call, info.method, info.step);
+        const info = resolveInfo(callee);
+        if (info?.method !== undefined) {
+            const applied = info.boundArgs === undefined ? call : { ...call, arguments: [...info.boundArgs, ...call.arguments] };
+            const subject = runtimeSubject(applied, info.method, info.step ?? info.owner);
             if (subject)
-                subject.functionName = fn?.name;
+                subject.functionName = info.runtimeFunction?.name;
             return subject;
         }
-        if (callee.type !== 'MemberExpression')
+        const member = unwrap(callee);
+        if (member.type !== 'MemberExpression')
             return undefined;
-        const name = memberName(callee);
+        const name = memberName(member);
         if (name === undefined)
             return undefined;
-        const { object } = callee;
-        // 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 = framework.thisMethods.has(name) ? thisFunction(call) : undefined;
-            return owner !== undefined && thisBodies.has(owner) ? runtimeSubject(call, name) : undefined;
-        }
-        if (object.type === 'Identifier') {
-            const info = resolveInfo(object);
-            return info?.methods?.has(name) ? runtimeSubject(call, name, info.step) : undefined;
-        }
+        const object = unwrap(member.object);
         const isTestInfo = RUNTIME_MODIFIERS.has(name) &&
             object.type === 'CallExpression' &&
             target(chainOf(object.callee, framework.factories))?.path.join('.') === 'info';
@@ -1723,20 +1956,37 @@ function runAnalysis(sourceCode, options) {
             const ownsThis = owner !== undefined && (thisBodies.has(owner) || suiteBodies.has(owner));
             return ownsThis ? retrySubject(call, call.arguments.at(0), name) : undefined;
         }
-        if (framework.retryCall !== 'jest.retryTimes' || name !== 'retryTimes' || object.type !== 'Identifier') {
+        if (framework.retryCall !== 'jest.retryTimes' || name !== 'retryTimes') {
             return undefined;
         }
-        const def = declaredVariable(sourceCode, object)?.defs.at(0);
-        const isJest = object.name === 'jest' &&
-            (def === undefined ||
-                (def.type === 'ImportBinding' &&
+        const isJestObject = (value, seen = []) => {
+            if (seen.includes(value))
+                return false;
+            if (value.type === 'MemberExpression')
+                return memberName(value) === 'jest' && moduleOf(value.object);
+            if (value.type !== 'Identifier' || isReassigned(sourceCode, value))
+                return false;
+            const def = declaredVariable(sourceCode, value)?.defs.at(0);
+            if (def === undefined)
+                return value.name === 'jest';
+            if (def.type === 'ImportBinding')
+                return (def.node.type === 'ImportSpecifier' &&
+                    importedName(def.node) === 'jest' &&
                     def.parent.type === 'ImportDeclaration' &&
-                    framework.ownsModule(def.parent.source.value)));
+                    framework.ownsModule(def.parent.source.value));
+            if (def.type === 'Variable' && def.node.id.type === 'ObjectPattern' && def.node.init !== null) {
+                const property = def.node.id.properties.find((prop) => prop.type === 'Property' && prop.value.type === 'Identifier' && prop.value.name === value.name);
+                return property?.type === 'Property' && propertyName(property) === 'jest' && moduleOf(def.node.init);
+            }
+            const alias = declaredValue(sourceCode, value);
+            return alias !== undefined && isJestObject(unwrap(alias), [...seen, value]);
+        };
+        const isJest = isJestObject(object);
         return isJest ? retrySubject(call, call.arguments.at(0), name) : undefined;
     };
     /** A call that gives retries when `count` does; retries need a ticket even when only some runs get them. */
     const retrySubject = (call, count, name) => {
-        if (!retries(count))
+        if (!retries(sourceCode, count))
             return undefined;
         const subject = runtimeSubject(call, 'retry', undefined, true);
         if (subject)
@@ -1744,7 +1994,7 @@ function runAnalysis(sourceCode, options) {
         return subject;
     };
     /** `step` is set for `step.skip()`, which skips only its step; the other calls act on the whole test. */
-    const runtimeSubject = (call, modifier, step, always = isUnconditional(call, framework)) => {
+    const runtimeSubject = (call, modifier, step, always = isUnconditional(sourceCode, call, framework)) => {
         if (!states.some((s) => s.modifier === modifier))
             return undefined;
         if (framework.reasonArgument !== 'only' && booleanOf(call.arguments.at(0)) === false)
@@ -1768,6 +2018,8 @@ function runAnalysis(sourceCode, options) {
                 pushedSubject = true;
             }
             for (const info of visit.infos ?? []) {
+                if (!info.runtimeFunction && info.step === undefined && visit.subject?.kind === 'test')
+                    info.owner = visit.subject;
                 infos.push(info);
                 pushedInfos++;
             }
@@ -1937,7 +2189,10 @@ export function headLoc(subject) {
     // todo test has only a title.
     const [first] = node.arguments;
     const title = isFunction(first) || first.type === 'ObjectExpression' ? undefined : first;
-    return { start: node.callee.loc.start, end: (title ?? node.callee).loc.end };
+    return {
+        start: node.callee.loc.start,
+        end: (title && title.range[1] > node.callee.range[1] ? title : node.callee).loc.end,
+    };
 }
 export function describeSubject(subject) {
     if (subject.kind === 'describe')

package/dist/utils/fix.js

@@ -28,9 +28,10 @@ export function removeMarkerComment(sourceCode, marker) {
         return { range: [valueStart + description.separator, valueStart + comment.value.trimEnd().length], text: '' };
     }
     const { text } = sourceCode;
-    const lineStart = text.lastIndexOf('\n', comment.range[0] - 1) + 1;
-    const newline = text.indexOf('\n', comment.range[1]);
-    const lineEnd = newline === -1 ? text.length : newline + 1;
+    const lineStart = sourceCode.getIndexFromLoc({ line: comment.loc.start.line, column: 0 });
+    const lineEnd = comment.loc.end.line < sourceCode.lines.length
+        ? sourceCode.getIndexFromLoc({ line: comment.loc.end.line + 1, column: 0 })
+        : text.length;
     const aloneOnLine = text.slice(lineStart, comment.range[0]).trim() === '' && text.slice(comment.range[1], lineEnd).trim() === '';
     return { range: aloneOnLine ? [lineStart, lineEnd] : comment.range, text: '' };
 }
@@ -47,7 +48,7 @@ export function indentOf(sourceCode, comment) {
 }
 const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
 function quote(text) {
-    return `'${text.replace(/[\\']/g, '\\$&')}'`;
+    return `'${text.replace(/[\\']/g, '\\$&').replace(/\r/g, '\\r').replace(/\n/g, '\\n')}'`;
 }
 /**
  * Moves a marker's tickets into an annotation on `call`: Playwright's `annotation` or Vitest's `meta`,
@@ -64,7 +65,7 @@ export function moveToAnnotation(sourceCode, call, marker, source, type) {
         return undefined;
     const one = (ticket) => `{ type: ${quote(type)}, description: ${quote(ticket)} }`;
     const value = source.shape === 'meta'
-        ? `{ ${IDENTIFIER_RE.test(type) ? type : quote(type)}: ${quote(tickets[0])} }`
+        ? `{ ${type === '__proto__' ? `[${quote(type)}]` : IDENTIFIER_RE.test(type) ? type : quote(type)}: ${quote(tickets[0])} }`
         : tickets.length === 1
             ? one(tickets[0])
             : `[${tickets.map(one).join(', ')}]`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-test-governance",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "description": "ESLint rules that require a ticket for skipped, fixme, todo, retried, tagged and commented-out Playwright, Jest, Vitest, Mocha, Cypress, WebdriverIO, node:test and Jasmine tests.",
   "keywords": [
     "eslint",