@ethlete/eslint-plugin 1.0.0-next.24 → 1.0.0-next.26

package/src/rules/no-direct-dom-manipulation.js

@@ -17,11 +17,12 @@
  *   element.classList.add('active')         → renderer.addClass(element, 'active')
  *   element.classList.remove('active')      → renderer.removeClass(element, 'active')
  *   element.style.color = 'red'             → renderer.setStyle(element, 'color', 'red')
+ *   Object.assign(element.style, { … })     → renderer.setStyle(element, prop, value) per property
  *
  * GOOD:
  *   private renderer = injectRenderer(); // from @ethlete/core
  *
- * NOTE: Calls where the receiver name contains 'renderer' (e.g. this.renderer.createElement)
+ * NOTE: Calls where the receiver name ends in 'renderer' (e.g. this.renderer.createElement)
  * are excluded — that is the correct injectRenderer() usage.
  */
 
@@ -62,16 +63,39 @@ const CLASSLIST_METHODS = new Map([
   ['replace', 'renderer.removeClass(el, old) + renderer.addClass(el, new)'],
 ]);
 
+/**
+ * @param {any} node
+ * @returns {string | null}
+ */
+const getMemberName = (node) => {
+  if (node.type !== 'MemberExpression') return null;
+  if (!node.computed && node.property.type === 'Identifier') return node.property.name;
+  if (node.computed && node.property.type === 'Literal' && typeof node.property.value === 'string') {
+    return node.property.value;
+  }
+
+  return null;
+};
+
+/**
+ * @param {any} node
+ * @returns {string | null}
+ */
+const getTerminalName = (node) => {
+  if (node.type === 'Identifier') return node.name;
+  if (node.type === 'MemberExpression') return getMemberName(node);
+  if (node.type === 'CallExpression') return getTerminalName(node.callee);
+  if (node.type === 'ChainExpression' || node.type === 'TSNonNullExpression') return getTerminalName(node.expression);
+
+  return null;
+};
+
 /**
  * Returns true when the receiver of a MemberExpression looks like a Renderer2 instance,
  * which means the call is already using the correct API.
- * @param {import('eslint').Rule.Node} objectNode
- * @param {import('eslint').Rule.RuleContext} context
+ * @param {any} objectNode
  */
-const isRendererReceiver = (objectNode, context) => {
-  const receiverText = context.sourceCode.getText(objectNode).toLowerCase();
-  return receiverText.includes('renderer');
-};
+const isRendererReceiver = (objectNode) => /renderer2?$/i.test(getTerminalName(objectNode) ?? '');
 
 /** @type {import('eslint').Rule.RuleModule} */
 const noDirectDomManipulation = {
@@ -96,16 +120,25 @@ const noDirectDomManipulation = {
       CallExpression(node) {
         const { callee } = node;
         if (callee.type !== 'MemberExpression') return;
-        if (callee.property.type !== 'Identifier') return;
 
-        const methodName = callee.property.name;
+        const [target] = node.arguments;
 
         if (
-          methodName === 'setProperty' &&
-          callee.object.type === 'MemberExpression' &&
-          callee.object.property.type === 'Identifier' &&
-          callee.object.property.name === 'style'
+          callee.object.type === 'Identifier' &&
+          callee.object.name === 'Object' &&
+          getMemberName(callee) === 'assign' &&
+          target &&
+          getMemberName(target) === 'style' &&
+          !isRendererReceiver(target.object)
         ) {
+          context.report({ node, messageId: 'domStyle' });
+          return;
+        }
+
+        const methodName = getMemberName(callee);
+        if (!methodName) return;
+
+        if (methodName === 'setProperty' && getMemberName(callee.object) === 'style') {
           context.report({
             node,
             messageId: 'domMutation',
@@ -117,12 +150,7 @@ const noDirectDomManipulation = {
           return;
         }
 
-        // ── classList.add / .remove / .toggle / .replace ─────────────────────
-        if (
-          callee.object.type === 'MemberExpression' &&
-          callee.object.property.type === 'Identifier' &&
-          callee.object.property.name === 'classList'
-        ) {
+        if (getMemberName(callee.object) === 'classList') {
           const alternative = CLASSLIST_METHODS.get(methodName);
           if (alternative) {
             context.report({
@@ -134,10 +162,8 @@ const noDirectDomManipulation = {
           return;
         }
 
-        // Skip calls on a Renderer2 instance — those are the correct pattern.
-        if (isRendererReceiver(callee.object, context)) return;
+        if (isRendererReceiver(callee.object)) return;
 
-        // ── DOM creation ──────────────────────────────────────────────────────
         if (DOM_CREATE_METHODS.has(methodName)) {
           context.report({
             node,
@@ -147,7 +173,6 @@ const noDirectDomManipulation = {
           return;
         }
 
-        // ── DOM mutation ──────────────────────────────────────────────────────
         if (DOM_MUTATION_METHODS.has(methodName)) {
           context.report({
             node,
@@ -157,15 +182,12 @@ const noDirectDomManipulation = {
         }
       },
 
-      // ── el.style.prop = value ─────────────────────────────────────────────
       AssignmentExpression(node) {
         const { left } = node;
         if (
           left.type === 'MemberExpression' &&
-          left.object.type === 'MemberExpression' &&
-          left.object.property.type === 'Identifier' &&
-          left.object.property.name === 'style' &&
-          !isRendererReceiver(left.object.object, context)
+          getMemberName(left.object) === 'style' &&
+          !isRendererReceiver(left.object.object)
         ) {
           context.report({ node, messageId: 'domStyle' });
         }

package/src/rules/no-document-cookie.js

@@ -39,16 +39,59 @@ const noDocumentCookie = {
     schema: [],
   },
   create(context) {
+    const documentAliases = new Set();
+    /** @type {any[]} */
+    const candidates = [];
+
+    const propertyName = (node) => {
+      if (!node.computed && node.property.type === 'Identifier') return node.property.name;
+      if (node.computed && node.property.type === 'Literal') return String(node.property.value);
+
+      return null;
+    };
+
+    const isGlobalObject = (node) =>
+      node.type === 'Identifier' &&
+      (node.name === 'window' || node.name === 'globalThis') &&
+      isGlobalReference(context.sourceCode, node);
+
+    const isInjectDocument = (node) =>
+      node?.type === 'CallExpression' &&
+      node.callee.type === 'Identifier' &&
+      node.callee.name === 'inject' &&
+      node.arguments[0]?.type === 'Identifier' &&
+      node.arguments[0].name === 'DOCUMENT';
+
+    const isDocument = (node) => {
+      if (node.type === 'Identifier') {
+        return node.name === 'document' && isGlobalReference(context.sourceCode, node);
+      }
+      if (node.type !== 'MemberExpression') return false;
+      if (propertyName(node) === 'document' && isGlobalObject(node.object)) return true;
+
+      return node.object.type === 'ThisExpression' && documentAliases.has(propertyName(node));
+    };
+
     return {
+      VariableDeclarator(node) {
+        if (node.id.type === 'Identifier' && isInjectDocument(node.init)) documentAliases.add(node.id.name);
+      },
+      PropertyDefinition(node) {
+        if (!node.computed && node.key.type === 'Identifier' && isInjectDocument(node.value)) {
+          documentAliases.add(node.key.name);
+        }
+      },
       MemberExpression(node) {
-        if (
-          node.object.type === 'Identifier' &&
-          node.object.name === 'document' &&
-          isGlobalReference(context.sourceCode, node.object) &&
-          node.property.type === 'Identifier' &&
-          node.property.name === 'cookie'
-        ) {
-          context.report({ node, messageId: 'noDocumentCookie' });
+        if (propertyName(node) === 'cookie') candidates.push(node);
+      },
+      'Program:exit'() {
+        for (const node of candidates) {
+          const object = node.object;
+          const isLocalAlias = object.type === 'Identifier' && documentAliases.has(object.name);
+
+          if (isLocalAlias || isDocument(object)) {
+            context.report({ node, messageId: 'noDocumentCookie' });
+          }
         }
       },
     };

package/src/rules/no-dom-query.js

@@ -62,9 +62,12 @@ const noDomQuery = {
       CallExpression(node) {
         const { callee } = node;
         if (callee.type !== 'MemberExpression') return;
-        if (callee.property.type !== 'Identifier') return;
 
-        const methodName = callee.property.name;
+        let methodName;
+        if (!callee.computed && callee.property.type === 'Identifier') methodName = callee.property.name;
+        else if (callee.computed && callee.property.type === 'Literal') methodName = String(callee.property.value);
+        else return;
+
         const alternative = DOM_QUERY_METHODS.get(methodName);
         if (!alternative) return;
 

package/src/rules/no-empty-angular-metadata-arrays.js

@@ -27,6 +27,7 @@ const noEmptyAngularMetadataArrays = {
     type: 'suggestion',
     docs: {
       description: 'Disallow empty Angular metadata arrays such as imports: [] and hostDirectives: [].',
+      recommended: true,
     },
     fixable: 'code',
     schema: [],
@@ -56,6 +57,7 @@ const noEmptyAngularMetadataArrays = {
 
           const propertyName = getPropertyName(property.key);
           if (propertyName !== 'imports' && propertyName !== 'hostDirectives') continue;
+          if (propertyName === 'imports' && decoratorName !== 'Component') continue;
           if (property.value.type !== 'ArrayExpression' || property.value.elements.length > 0) continue;
 
           context.report({

package/src/rules/no-empty-newlines-between-imports.js

@@ -7,6 +7,7 @@ const noEmptyNewlinesBetweenImports = {
     type: 'layout',
     docs: {
       description: 'Disallow empty blank lines between consecutive import declarations.',
+      recommended: true,
     },
     fixable: 'code',
     schema: [],
@@ -33,7 +34,9 @@ const noEmptyNewlinesBetweenImports = {
             node: currentImport,
             messageId: 'noEmptyLine',
             fix(fixer) {
-              return fixer.replaceTextRange([previousImport.range[1], currentImport.range[0]], '\n');
+              const lineBreak = textBetween.includes('\r\n') ? '\r\n' : '\n';
+
+              return fixer.replaceTextRange([previousImport.range[1], currentImport.range[0]], lineBreak);
             },
           });
         }

package/src/rules/no-impure-top-level-provider.js

@@ -34,14 +34,36 @@ const calleeName = (node) => {
   return null;
 };
 
-/** Every call/`new` in an initializer that really is evaluated when the module is imported. */
-const collectImportTimeCalls = (root) => {
-  const found = [];
+const TRANSPARENT_WRAPPERS = new Set([
+  'TSAsExpression',
+  'TSSatisfiesExpression',
+  'TSNonNullExpression',
+  'TSTypeAssertion',
+]);
+
+const unwrap = (node) => (TRANSPARENT_WRAPPERS.has(node.type) ? unwrap(node.expression) : node);
+
+const isConstantExpression = (node) =>
+  node.type === 'Literal' ||
+  (node.type === 'UnaryExpression' && isConstantExpression(node.argument)) ||
+  (node.type === 'BinaryExpression' && isConstantExpression(node.left) && isConstantExpression(node.right));
+
+/** Everything in an initializer that really is evaluated when the module is imported and that a bundler cannot drop. */
+const collectImportTimeNodes = (root) => {
+  const calls = [];
+  const reads = [];
 
   const visit = (node) => {
     if (!node || typeof node.type !== 'string' || NOT_EVALUATED_ON_IMPORT.has(node.type)) return;
 
-    if (node.type === 'CallExpression' || node.type === 'NewExpression') found.push(node);
+    if (node.type === 'CallExpression' || node.type === 'NewExpression') calls.push(node);
+    else if (node.type === 'SpreadElement') reads.push(node);
+    else if (node.type === 'BinaryExpression' && !isConstantExpression(node)) reads.push(node);
+    else if (
+      node.type === 'MemberExpression' &&
+      !(node.parent.type === 'CallExpression' && node.parent.callee === node)
+    )
+      reads.push(node);
 
     for (const key of Object.keys(node)) {
       if (key === 'parent') continue;
@@ -55,7 +77,7 @@ const collectImportTimeCalls = (root) => {
 
   visit(root);
 
-  return found;
+  return { calls, reads };
 };
 
 /** @type {import('eslint').Rule.RuleModule} */
@@ -65,6 +87,7 @@ const noImpureTopLevelProvider = {
     docs: {
       description:
         'Disallow module-scope destructuring of a factory call, and require a pure annotation on module-scope calls in library source.',
+      recommended: true,
     },
     fixable: 'code',
     schema: [
@@ -76,6 +99,11 @@ const noImpureTopLevelProvider = {
             description:
               'Also require `@__PURE__` on every call evaluated at module scope. Turn this on in publishable library source; it is pointless in application code, where every statement is retained anyway.',
           },
+          forbidImpureReads: {
+            type: 'boolean',
+            description:
+              'Also forbid member reads, spreads and arithmetic on identifiers in module-scope initializers, which bundlers cannot prove side-effect free.',
+          },
         },
         additionalProperties: false,
       },
@@ -83,6 +111,8 @@ const noImpureTopLevelProvider = {
     messages: {
       noDestructuring:
         'Do not destructure a factory call at module scope. Destructuring invokes the iterator protocol, so no bundler can drop the statement — everything the factory closes over ships to every consumer. Assign the result to one `const` and name each binding with its own annotated extractor (`toProvideFn` / `toInjectFn` / `toToken`).',
+      impureRead:
+        'This module-scope member read, spread or arithmetic on an identifier cannot be proven side-effect free, so the whole declaration is retained in every consumer bundle. Write the literal key or number instead, or move the expression inside a function.',
       missingPure:
         'This module-scope call to `{{name}}` needs a `/* @__PURE__ */` annotation, or the whole declaration is retained in every consumer bundle — one unannotated call anywhere in an initializer (including inside an argument or an object literal) is enough. If the call is genuinely not side-effect free at import time, move it inside a function instead of annotating it: library code must not do work on import.',
     },
@@ -90,12 +120,13 @@ const noImpureTopLevelProvider = {
   create(context) {
     const sourceCode = context.sourceCode;
     const requirePureAnnotation = context.options[0]?.requirePureAnnotation === true;
+    const forbidImpureReads = context.options[0]?.forbidImpureReads === true;
 
     return {
       VariableDeclarator(node) {
         if (!isModuleScope(node) || !node.init) return;
 
-        const initializer = node.init.type === 'TSAsExpression' ? node.init.expression : node.init;
+        const initializer = unwrap(node.init);
 
         if (
           initializer.type === 'CallExpression' &&
@@ -108,7 +139,11 @@ const noImpureTopLevelProvider = {
 
         if (!requirePureAnnotation || node.id.type !== 'Identifier') return;
 
-        for (const call of collectImportTimeCalls(initializer)) {
+        const { calls, reads } = collectImportTimeNodes(initializer);
+
+        if (forbidImpureReads) for (const read of reads) context.report({ node: read, messageId: 'impureRead' });
+
+        for (const call of calls) {
           const name = calleeName(call);
 
           if (name === null || hasPureAnnotation(sourceCode, call)) continue;

package/src/rules/no-leading-underscore-class-member.js

@@ -11,7 +11,7 @@ const getFixedName = (name) => name.replace(/^_+/, '');
  */
 const getDirectMemberName = (node) => {
   if (node.parent?.type !== 'ClassBody') return null;
-  if (node.static || node.computed) return null;
+  if (node.computed) return null;
   if (node.type === 'MethodDefinition' && node.kind === 'constructor') return null;
   return node.key?.type === 'Identifier' ? node.key.name : null;
 };
@@ -32,6 +32,7 @@ const noLeadingUnderscoreClassMember = {
     type: 'suggestion',
     docs: {
       description: 'Disallow leading underscores on class members and rename private members automatically when safe.',
+      recommended: true,
     },
     fixable: 'code',
     schema: [],
@@ -98,7 +99,13 @@ const noLeadingUnderscoreClassMember = {
             !frame.declaredNames.has(newName) &&
             targetNameCounts.get(newName) === 1 &&
             !frame.untrackedNames.has(oldName) &&
-            memberNodes.every((memberNode) => memberNode.accessibility === 'private');
+            memberNodes.every(
+              (memberNode) =>
+                memberNode.accessibility === 'private' &&
+                !memberNode.static &&
+                !memberNode.abstract &&
+                !memberNode.parameterProperty,
+            );
 
           for (const memberNode of memberNodes) {
             context.report({
@@ -124,6 +131,24 @@ const noLeadingUnderscoreClassMember = {
 
       PropertyDefinition: registerMember,
       MethodDefinition: registerMember,
+      AccessorProperty: registerMember,
+      TSAbstractPropertyDefinition: registerMember,
+      TSAbstractMethodDefinition: registerMember,
+      TSAbstractAccessorProperty: registerMember,
+
+      TSParameterProperty(node) {
+        const frame = classStack[classStack.length - 1];
+        const parameter = node.parameter.type === 'AssignmentPattern' ? node.parameter.left : node.parameter;
+        if (!frame || parameter.type !== 'Identifier') return;
+
+        frame.declaredNames.add(parameter.name);
+
+        if (!parameter.name.startsWith('_')) return;
+
+        const members = frame.membersByName.get(parameter.name) ?? [];
+        members.push({ key: parameter, accessibility: node.accessibility, parameterProperty: true });
+        frame.membersByName.set(parameter.name, members);
+      },
 
       MemberExpression(node) {
         const frame = classStack[classStack.length - 1];

package/src/rules/no-legacy-angular-decorators.js

@@ -27,6 +27,15 @@ const { getAngularDecoratorName } = require('./internals/import-resolution');
  *   → ✅ host: { '[class.active]': 'isActive', '(click)': 'onClick()' }
  */
 
+const CLASS_MEMBER_TYPES = new Set([
+  'PropertyDefinition',
+  'MethodDefinition',
+  'AccessorProperty',
+  'TSAbstractPropertyDefinition',
+  'TSAbstractMethodDefinition',
+  'TSAbstractAccessorProperty',
+]);
+
 /**
  * Returns the static string key of a class member, or null for computed keys.
  *
@@ -219,6 +228,7 @@ const rule = {
     docs: {
       description:
         'Disallow legacy Angular decorators (@Input, @Output, @ViewChild, etc.) in favour of signal-based APIs and host: {} bindings.',
+      recommended: true,
     },
     fixable: 'code',
     schema: [],
@@ -256,7 +266,6 @@ const rule = {
       const reportedInputNames = new Set();
       const reportedOutputNames = new Set();
 
-      // Detect @Input() x + @Output() xChange pairs → suggest model()
       for (const [outputName, outputDecoratorNode] of ctx.outputs) {
         if (!outputName.endsWith('Change')) continue;
         const inputName = outputName.slice(0, -'Change'.length);
@@ -277,14 +286,12 @@ const rule = {
         });
       }
 
-      // Report remaining @Input() decorators that are not part of a pair
       for (const [name, decoratorNode] of ctx.inputs) {
         if (!reportedInputNames.has(name)) {
           context.report({ node: decoratorNode, messageId: 'useInput' });
         }
       }
 
-      // Report remaining @Output() decorators that are not part of a pair
       for (const [name, decoratorNode] of ctx.outputs) {
         if (!reportedOutputNames.has(name)) {
           context.report({ node: decoratorNode, messageId: 'useOutput' });
@@ -303,10 +310,9 @@ const rule = {
         const decoratorName = getAngularDecoratorName(context.sourceCode, anyNode);
         if (!decoratorName) return;
 
-        // Only act on decorators attached to class members, not to the class itself
         const parent = anyNode.parent;
         if (!parent) return;
-        if (parent.type !== 'PropertyDefinition' && parent.type !== 'MethodDefinition') return;
+        if (!CLASS_MEMBER_TYPES.has(parent.type)) return;
 
         const ctx = currentClass();
 
@@ -320,7 +326,6 @@ const rule = {
             if (memberName !== null) {
               ctx.inputs.set(memberName, node);
             } else {
-              // Computed key — cannot be part of a two-way binding pair, report immediately
               context.report({ node, messageId: 'useInput' });
             }
             break;

package/src/rules/no-legacy-prepare-without-injector.js

@@ -101,9 +101,16 @@ const isContextProvidingHost = (host) => {
  */
 const isTransparentHost = (host) =>
   !!host &&
-  host.callee.type === 'MemberExpression' &&
-  host.callee.property.type === 'Identifier' &&
-  TRANSPARENT_ARRAY_METHODS.has(host.callee.property.name);
+  ((host.callee.type === 'Identifier' && host.callee.name === 'untracked') ||
+    (host.callee.type === 'MemberExpression' &&
+      host.callee.property.type === 'Identifier' &&
+      TRANSPARENT_ARRAY_METHODS.has(host.callee.property.name)));
+
+/**
+ * @param {any} fn
+ * @returns {boolean}
+ */
+const isImmediatelyInvoked = (fn) => fn.parent?.type === 'CallExpression' && fn.parent.callee === fn;
 
 /**
  * Whether the function's own body calls `inject()`. Such a function can only be called from an injection
@@ -175,7 +182,7 @@ const classifyCallSite = (node) => {
         return { needsInjector: false, boundary: 'injection context' };
       }
 
-      if (!isTransparentHost(host)) {
+      if (!isTransparentHost(host) && !isImmediatelyInvoked(current)) {
         if (!host && callsInject(current)) {
           return { needsInjector: false, boundary: 'function that injects' };
         }
@@ -281,6 +288,31 @@ const noLegacyPrepareWithoutInjector = {
     }
     /** Names known to be legacy creators: imported under the naming convention, or declared locally. */
     const creatorNames = new Set();
+    /** @type {Set<string>} */
+    const namespaceNames = new Set();
+
+    /**
+     * @param {any} object
+     * @returns {string | null}
+     */
+    const getCreatorName = (object) => {
+      if (object.type === 'Identifier') {
+        return creatorNames.has(object.name) ? object.name : null;
+      }
+
+      if (
+        object.type === 'MemberExpression' &&
+        !object.computed &&
+        object.object.type === 'Identifier' &&
+        namespaceNames.has(object.object.name) &&
+        object.property.type === 'Identifier' &&
+        creatorPattern.test(object.property.name)
+      ) {
+        return `${object.object.name}.${object.property.name}`;
+      }
+
+      return null;
+    };
 
     /**
      * @param {any} classBody
@@ -288,11 +320,12 @@ const noLegacyPrepareWithoutInjector = {
      */
     const buildInjectorMemberFix = (classBody, injectorName) => {
       const firstMember = classBody.body[0];
-      const indentation = ' '.repeat(firstMember ? firstMember.loc.start.column : 2);
+      const insertBefore = firstMember ? (sourceCode.getCommentsBefore(firstMember)[0] ?? firstMember) : null;
+      const indentation = ' '.repeat(insertBefore ? insertBefore.loc.start.column : 2);
       const declaration = `private ${injectorName} = inject(Injector);`;
 
-      return firstMember
-        ? /** @param {any} fixer */ (fixer) => fixer.insertTextBefore(firstMember, `${declaration}\n\n${indentation}`)
+      return insertBefore
+        ? /** @param {any} fixer */ (fixer) => fixer.insertTextBefore(insertBefore, `${declaration}\n\n${indentation}`)
         : /** @param {any} fixer */ (fixer) => fixer.replaceText(classBody, `{\n${indentation}${declaration}\n}`);
     };
 
@@ -393,7 +426,15 @@ const noLegacyPrepareWithoutInjector = {
           if (node.type === 'ImportDeclaration') {
             node.specifiers.forEach(
               /** @param {any} specifier */ (specifier) => {
-                if (specifier.type === 'ImportSpecifier' && creatorPattern.test(specifier.local.name)) {
+                if (specifier.type === 'ImportNamespaceSpecifier') {
+                  namespaceNames.add(specifier.local.name);
+                }
+
+                if (specifier.type !== 'ImportSpecifier') return;
+
+                const importedName = specifier.imported.name ?? specifier.imported.value;
+
+                if (creatorPattern.test(specifier.local.name) || creatorPattern.test(importedName)) {
                   creatorNames.add(specifier.local.name);
                 }
               },
@@ -433,13 +474,17 @@ const noLegacyPrepareWithoutInjector = {
         if (
           callee.type !== 'MemberExpression' ||
           callee.property.type !== 'Identifier' ||
-          callee.property.name !== 'prepare' ||
-          callee.object.type !== 'Identifier' ||
-          !creatorNames.has(callee.object.name)
+          callee.property.name !== 'prepare'
         ) {
           return;
         }
 
+        const creatorName = getCreatorName(callee.object);
+
+        if (!creatorName) {
+          return;
+        }
+
         const firstArgument = /** @type {any} */ (node.arguments[0]);
         const hasInjector =
           firstArgument?.type === 'ObjectExpression' &&
@@ -479,7 +524,7 @@ const noLegacyPrepareWithoutInjector = {
         context.report({
           node,
           messageId: 'missingInjector',
-          data: { creator: callee.object.name, boundary },
+          data: { creator: creatorName, boundary },
           // Only the in-class shape is auto-fixed: a standalone function has no obvious injector to reach
           // for, and inventing an `inject()` call there would move the failure rather than fix it.
           fix: