@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.4

package/src/sweep.ts

@@ -33,6 +33,8 @@ export interface Exemption {
    * The record holds only while one of them is called through its interface.
    */
   readonly implementing?: Implementing;
+  /** Whether the record holds only where a write the mode counts stores into the declaration. */
+  readonly whileWritten?: true;
 }
 
 /** The interface methods one retained class member implements, and whether its body is empty. */
@@ -195,10 +197,14 @@ export function runnerCalls(symbol: InventorySymbol): boolean {
  * That run's roots are the graph's own and, of each test file, its top level and every
  * function it exports, which a test runner may call, and every export of a manual mock,
  * which the runner reads; any other export of a test file, and test-support code, which
- * runs where a test imports it, are judged as any file's are.
- * `held` seeds it as a mark or an exemption seeds a sweep.
+ * runs where a test imports it, are judged as any file's are. `held` seeds it as a mark
+ * seeds a sweep; with `namespaces` false a file read reaches none of the file's exports.
  */
-export function reachedWithTheTests(graph: Graph, held: readonly string[]): readonly boolean[] {
+export function reachedWithTheTests(
+  graph: Graph,
+  held: readonly string[],
+  namespaces = true,
+): readonly boolean[] {
   const tests = graph.symbols.flatMap((symbol, at) => {
     const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
     const called = exported && runnerCalls(symbol);
@@ -208,9 +214,12 @@ export function reachedWithTheTests(graph: Graph, held: readonly string[]): read
       ? [{ at, kind: "test-runner" as const }]
       : [];
   });
-  return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
-    production: false,
-  });
+  return reachable(
+    { ...graph, rooted: [...graph.rooted, ...tests] },
+    flagged(graph, held),
+    { production: false },
+    namespaces,
+  );
 }
 
 /**
@@ -240,7 +249,12 @@ function flagged(graph: Graph, ids: readonly string[]): boolean[] {
  * included, while a root reaches through the references the mode counts. The held seed
  * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly boolean[] {
+function reachable(
+  graph: Graph,
+  held: readonly boolean[],
+  mode: Mode,
+  namespaces = true,
+): readonly boolean[] {
   const reached = graph.symbols.map(() => false);
   const expanded = graph.symbols.map(() => false);
   const queue: number[] = [];
@@ -269,7 +283,7 @@ function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly
         if (!holding && mode.production && edge.test) {
           continue;
         }
-        enter(edge.to, !edge.evaluation);
+        enter(edge.to, namespaces && !edge.evaluation);
       }
     }
   };
@@ -285,7 +299,7 @@ function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly
   }
   // A consumer's reference reaches what it names as one of the target's own does.
   for (const edge of callsOf(graph, mode)) {
-    enter(edge.to, !edge.evaluation);
+    enter(edge.to, namespaces && !edge.evaluation);
   }
   walk(false);
   return reached;

package/src/test-globals.ts

@@ -0,0 +1,275 @@
+/**
+ * The globals a test runner injects into every file it runs, which no import names: a
+ * Vitest configuration whose `test.globals` is `true` gives each test and each file it
+ * loads `describe`, `it`, `expect` and `vi` (https://vitest.dev/config/globals). A program
+ * analyzed without the runner's declarations of them reads every use as an error, so a
+ * configuration under such a runner is read with them; and a file that calls one is
+ * written for the runner, as one that imports it is.
+ */
+
+import {
+  isAsExpression,
+  isBinaryExpression,
+  isCallExpression,
+  isExportAssignment,
+  isExpressionStatement,
+  isIdentifier,
+  isObjectLiteralExpression,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isPropertyAssignment,
+  isSatisfiesExpression,
+  SyntaxKind,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import type { ParseFile } from "./configuration-files.ts";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath } from "./paths.ts";
+import { UNANSWERED } from "./query.ts";
+import type { Engine, ProjectView } from "./session.ts";
+import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+
+/** The test runner whose configuration injects the globals, and the `types` entry declaring them. */
+export const GLOBALS_RUNNER = "vitest";
+const GLOBALS_TYPES = "vitest/globals";
+
+/** The configuration files the runner reads its settings from, by name. */
+const RUNNER_CONFIG = /^(?:vitest|vite)\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u;
+
+/** The globals `vitest/globals` declares that a test or a helper calls or reads a member of. */
+const GLOBAL_NAMES: ReadonlySet<string> = new Set([
+  "afterAll",
+  "afterEach",
+  "assert",
+  "assertType",
+  "beforeAll",
+  "beforeEach",
+  "bench",
+  "describe",
+  "expect",
+  "expectTypeOf",
+  "it",
+  "onTestFailed",
+  "onTestFinished",
+  "suite",
+  "test",
+  "vi",
+  "vitest",
+]);
+
+/** The expression one wrapper that changes no value holds, and a call's first argument. */
+function configObject(node: Node): Node | undefined {
+  let at: Node | undefined = node;
+  while (at !== undefined) {
+    if (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+      at = at.expression;
+    } else if (isCallExpression(at)) {
+      at = at.arguments[0];
+    } else {
+      return at;
+    }
+  }
+  return undefined;
+}
+
+/** The value one object literal writes for one member as `name: value`. */
+function member(object: Node | undefined, name: string): Node | undefined {
+  if (object === undefined || !isObjectLiteralExpression(object)) {
+    return undefined;
+  }
+  for (const property of object.properties) {
+    if (
+      isPropertyAssignment(property) &&
+      isIdentifier(property.name) &&
+      property.name.text === name
+    ) {
+      return configObject(property.initializer);
+    }
+  }
+  return undefined;
+}
+
+/** Whether one runner configuration's default export sets `test.globals` to `true`. */
+function setsGlobals(file: SourceFile): boolean {
+  for (const statement of file.statements) {
+    let exported: Node | undefined;
+    if (isExportAssignment(statement)) {
+      exported = statement.expression;
+    } else if (isExpressionStatement(statement) && isBinaryExpression(statement.expression)) {
+      const { left, operatorToken, right } = statement.expression;
+      if (
+        operatorToken.kind === SyntaxKind.EqualsToken &&
+        isPropertyAccessExpression(left) &&
+        isIdentifier(left.expression) &&
+        left.expression.text === "module" &&
+        isIdentifier(left.name) &&
+        left.name.text === "exports"
+      ) {
+        exported = right;
+      }
+    }
+    const object = exported === undefined ? undefined : configObject(exported);
+    const globals = member(member(object, "test"), "globals");
+    if (globals?.kind === SyntaxKind.TrueKeyword) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Whether the runner's configuration in one manifest's directory injects the globals. */
+function injectsGlobals(host: Host, parse: ParseFile, dir: string): boolean {
+  let names: readonly string[];
+  try {
+    names = host
+      .readDirectory(dir)
+      .filter((entry) => !entry.directory && RUNNER_CONFIG.test(entry.name))
+      .map((entry) => entry.name);
+  } catch {
+    return false;
+  }
+  return names.some((name) => {
+    const path = joinPath(dir, name);
+    try {
+      return setsGlobals(parse(path, host.readFile(path)));
+    } catch {
+      return false;
+    }
+  });
+}
+
+/** Whether a file declaring the globals is installed where the configuration resolves packages from. */
+function globalsInstalled(host: Host, configFile: string): boolean {
+  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
+    if (host.kindOf(joinPath(dir, "node_modules", GLOBALS_RUNNER, "globals.d.ts")) === "file") {
+      return true;
+    }
+    if (dirnamePath(dir) === dir) {
+      return false;
+    }
+  }
+}
+
+/** The directory of the manifest nearest one configuration file, at or above its own. */
+function manifestDir(host: Host, configFile: string): string | undefined {
+  for (let dir = dirnamePath(configFile); ; dir = dirnamePath(dir)) {
+    if (host.kindOf(joinPath(dir, "package.json")) === "file") {
+      return dir;
+    }
+    if (dirnamePath(dir) === dir) {
+      return undefined;
+    }
+  }
+}
+
+function typesOf(value: unknown): readonly string[] | undefined {
+  return Array.isArray(value) && value.every((one) => typeof one === "string") ? value : undefined;
+}
+
+/**
+ * How the snapshot reads each configuration of `configFiles` whose nearest manifest's
+ * runner configuration injects the globals and that can resolve their declarations: as
+ * `programs` reads it, else as itself, with the globals' declarations added to its `types`.
+ * A configuration the compiler cannot read is left for its project to refuse.
+ */
+export function withTestGlobals(
+  engine: Engine,
+  host: Host,
+  parse: ParseFile,
+  configFiles: readonly string[],
+  programs: ReadonlyMap<string, WorkspaceProgram>,
+): ReadonlyMap<string, WorkspaceProgram> {
+  const found = new Map(programs);
+  const injects = new Map<string, boolean>();
+  for (const configFile of configFiles) {
+    const dir = manifestDir(host, configFile);
+    if (dir === undefined || !globalsInstalled(host, configFile)) {
+      continue;
+    }
+    if (!injects.has(dir)) {
+      injects.set(dir, injectsGlobals(host, parse, dir));
+    }
+    if (injects.get(dir) !== true) {
+      continue;
+    }
+    let base: readonly string[];
+    try {
+      base = typesOf(engine.parseConfigFile(configFile).options.types) ?? [];
+    } catch {
+      continue;
+    }
+    const held = found.get(configFile);
+    if (held?.kind === "program") {
+      const listed = typesOf(held.params.compilerOptions.types) ?? base;
+      if (!listed.includes(GLOBALS_TYPES)) {
+        found.set(configFile, {
+          kind: "program",
+          params: {
+            ...held.params,
+            compilerOptions: { ...held.params.compilerOptions, types: [...listed, GLOBALS_TYPES] },
+          },
+        });
+      }
+      continue;
+    }
+    let written: Record<string, unknown> = { extends: configFile };
+    if (held !== undefined) {
+      try {
+        written = JSON.parse(held.text) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+    }
+    const options = (written["compilerOptions"] ?? {}) as Record<string, unknown>;
+    const listed = typesOf(options["types"]) ?? base;
+    if (listed.includes(GLOBALS_TYPES)) {
+      continue;
+    }
+    found.set(configFile, {
+      kind: "configuration",
+      file: held?.file ?? writtenPath(host, configFile),
+      text: `${JSON.stringify(
+        { ...written, compilerOptions: { ...options, types: [...listed, GLOBALS_TYPES] } },
+        null,
+        2,
+      )}\n`,
+    });
+  }
+  return found;
+}
+
+/**
+ * Whether one file names a global the runner injects, which is how a file written for the
+ * runner's globals reads: a call of one of the names or a read of a member of it that
+ * resolves to a declaration outside the project's own files, the runner's declaration
+ * file. A name the file binds, imported, declared or a parameter, resolves to its own.
+ */
+export function namesTestGlobals<Brand>(project: ProjectView<Brand>, file: SourceFile): boolean {
+  const named: Node[] = [];
+  const visit = (node: Node): void => {
+    const callee = isCallExpression(node)
+      ? node.expression
+      : isPropertyAccessExpression(node)
+        ? node.expression
+        : undefined;
+    if (callee !== undefined && isIdentifier(callee) && GLOBAL_NAMES.has(callee.text)) {
+      named.push(callee);
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  if (named.length === 0) {
+    return false;
+  }
+  const own = project.ownPaths();
+  return project
+    .symbolsAt(named.map((node) => project.handle(node)))
+    .some(
+      (symbol) =>
+        symbol === UNANSWERED ||
+        (symbol !== undefined &&
+          symbol.declarations.length > 0 &&
+          symbol.declarations.every((handle) => !own.has(handle.path))),
+    );
+}

package/src/type-errors.ts

@@ -31,6 +31,13 @@ import { findWorkspace, type Workspace } from "./workspace.ts";
 /** The compiler's codes for an import whose module it cannot find. */
 const MODULE_NOT_FOUND: ReadonlySet<number> = new Set([2307, 2792]);
 
+/**
+ * The compiler's codes for where the configuration places a file, which leave every type
+ * the file's statements carry as it is: an output that would overwrite an input (5055,
+ * 5056), a file outside `rootDir` (6059), one a composite project does not list (6307).
+ */
+const CONFIGURATION_LEVEL: ReadonlySet<number> = new Set([5055, 5056, 6059, 6307]);
+
 const MANIFEST = "package.json";
 const MANIFEST_SECTIONS = [
   "dependencies",
@@ -290,8 +297,8 @@ function messageOf(text: string, targetRoot: string): string {
 
 /**
  * Reads the errors one project's own files carry. A diagnostic marking unnecessary code
- * is no error here, and one in a file that is not the project's own is that file's
- * package's to answer for.
+ * or about where the configuration places a file is no error here, and one in a file that
+ * is not the project's own is that file's package's to answer for.
  */
 export function readErrors<Brand>(
   project: ProjectView<Brand>,
@@ -313,7 +320,11 @@ export function readErrors<Brand>(
   const skips: Skip[] = [];
   for (const { diagnostic, at } of errors) {
     const file = diagnostic.fileName === undefined ? undefined : files.get(diagnostic.fileName);
-    if (file === undefined || diagnostic.reportsUnnecessary === true) {
+    if (
+      file === undefined ||
+      diagnostic.reportsUnnecessary === true ||
+      CONFIGURATION_LEVEL.has(diagnostic.code)
+    ) {
       continue;
     }
     const path = relativePath(context.targetRoot, file.fileName) ?? file.fileName;

package/src/unseen-loads.ts

@@ -0,0 +1,145 @@
+/**
+ * The loads of a project's production files whose target the analysis cannot resolve: an
+ * `import()` or `require()` call whose path is computed and starts with no relative literal
+ * naming a directory below the calling file's. The files such a load runs are roots the
+ * analysis does not see, so the configuration's roots are never complete.
+ */
+
+import {
+  isAsExpression,
+  isBinaryExpression,
+  isCallExpression,
+  isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isParenthesizedExpression,
+  isSatisfiesExpression,
+  isStringLiteral,
+  isTemplateExpression,
+  SyntaxKind,
+  type Node,
+} from "@typescript/native/ast";
+import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
+import { renderPosition, type Position } from "./position.ts";
+import { UNANSWERED } from "./query.ts";
+import type { ProjectView } from "./session.ts";
+import { sourceFilesOf } from "./source-files.ts";
+
+/** One load the analysis cannot resolve, in the configuration whose production file writes it. */
+export interface UnseenLoad {
+  readonly configuration: string;
+  /** The position of the call. */
+  readonly position: Position;
+}
+
+/** The expression a wrapper that changes no value holds: parentheses and type assertions. */
+function unwrapped(node: Node): Node {
+  let at = node;
+  while (isParenthesizedExpression(at) || isAsExpression(at) || isSatisfiesExpression(at)) {
+    at = at.expression;
+  }
+  return at;
+}
+
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+export function leadingLiteral(node: Node): string | undefined {
+  const at = unwrapped(node);
+  if (isTemplateExpression(at)) {
+    return at.head.text;
+  }
+  if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+    const left = unwrapped(at.left);
+    return isStringLiteral(left) || isNoSubstitutionTemplateLiteral(left)
+      ? left.text
+      : leadingLiteral(at.left);
+  }
+  return undefined;
+}
+
+/**
+ * The directory below `dir` a computed load's leading literal names, which the entry
+ * rules root every file of, or none where it names a package, `dir` itself or a
+ * directory holding it, each of which would name files no rule roots.
+ */
+export function computedLoadDirectory(dir: string, prefix: string): string | undefined {
+  if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
+    return undefined;
+  }
+  const target = resolvePath(dir, prefix);
+  return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+
+/** Whether a computed path's leading literal names a package, whose files are none of the target's. */
+function namesPackage(prefix: string | undefined): boolean {
+  return (
+    prefix !== undefined &&
+    prefix !== "" &&
+    !prefix.startsWith(".") &&
+    !prefix.startsWith("/") &&
+    !/^[A-Za-z][A-Za-z\d+.-]*:/u.test(prefix)
+  );
+}
+
+/**
+ * Every unresolved load the project's production files write, in file then source order.
+ * `testFiles` holds the test files by their path below the target root. A `require` call
+ * loads a module only where the name resolves to no declaration of the project's own
+ * files: one the project declares is its own function.
+ */
+export function unseenLoadsOf<Brand>(
+  project: ProjectView<Brand>,
+  configuration: string,
+  targetRoot: string,
+  testFiles: readonly string[],
+): readonly UnseenLoad[] {
+  const tests = new Set(testFiles);
+  const sites: { readonly position: Position; readonly require: Node | undefined }[] = [];
+  for (const [path, file] of sourceFilesOf(project, targetRoot).byPath) {
+    if (tests.has(path) || file.isDeclarationFile) {
+      continue;
+    }
+    const dir = dirnamePath(file.fileName);
+    const visit = (node: Node): void => {
+      if (isCallExpression(node)) {
+        const callee = node.expression;
+        const required = isIdentifier(callee) && callee.text === "require";
+        const [first] = node.arguments;
+        const argument = first === undefined ? undefined : unwrapped(first);
+        if (
+          (callee.kind === SyntaxKind.ImportKeyword || required) &&
+          argument !== undefined &&
+          !isStringLiteral(argument) &&
+          !isNoSubstitutionTemplateLiteral(argument)
+        ) {
+          const prefix = leadingLiteral(argument);
+          const seen =
+            namesPackage(prefix) ||
+            (prefix !== undefined && computedLoadDirectory(dir, prefix) !== undefined);
+          if (!seen) {
+            sites.push({
+              position: renderPosition(file, targetRoot, node.getStart()),
+              require: required ? callee : undefined,
+            });
+          }
+        }
+      }
+      node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+  }
+  const requires = sites.flatMap((site) => (site.require === undefined ? [] : [site.require]));
+  const own = project.ownPaths();
+  const local = new Set<Node>();
+  project.symbolsAt(requires.map((node) => project.handle(node))).forEach((symbol, at) => {
+    const node = requires[at];
+    if (
+      node !== undefined &&
+      symbol !== UNANSWERED &&
+      symbol?.declarations.some((handle) => own.has(handle.path)) === true
+    ) {
+      local.add(node);
+    }
+  });
+  return sites
+    .filter((site) => site.require === undefined || !local.has(site.require))
+    .map((site) => ({ configuration, position: site.position }));
+}

package/src/verbs/analyze.ts

@@ -10,7 +10,7 @@ import { ConfigError, kindOf, type Format } from "../config.ts";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.ts";
 import { moduleIdentity } from "../consumers.ts";
 import { analyzerProvenance, verdictOf } from "../findings-pass.ts";
-import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
+import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.ts";
 import type { Host } from "../host.ts";
 import type { ManifestEntry } from "../manifest.ts";
 import type { NotBuilt } from "../discover.ts";
@@ -30,6 +30,7 @@ import { RENDERINGS } from "../reporters/reporters.ts";
 import { parseTemplate, TemplateError, type Template } from "../reporters/template.ts";
 import { resolve } from "../resolve.ts";
 import { otherSchemeRows, rowReason, writeBaseline, type Recorded } from "../suppress-file.ts";
+import type { UnseenLoad } from "../unseen-loads.ts";
 import { CONTRACT_VERSION } from "../version.ts";
 import { EXIT_CLEAN, EXIT_FAILURE, type Verb, type VerbOptions } from "./verb.ts";
 
@@ -113,6 +114,27 @@ function unmappedNotes(
   });
 }
 
+/**
+ * One note per load of a production file the run cannot resolve, each site once: a file
+ * it loads is a root the run does not see, so `ts.roots_complete` lifts no cap there.
+ */
+function unseenLoadNotes(loads: readonly UnseenLoad[]): readonly ReportNote[] {
+  return [
+    ...new Map(
+      loads.map((load) => {
+        const { path, line, column } = load.position;
+        const site = `${path}:${String(line)}:${String(column)}`;
+        const note: ReportNote = {
+          kind: "computed-load",
+          path: dirnamePath(path),
+          message: `${site} loads a module by a computed path the analysis cannot resolve, so the configurations compiling it report what no root reaches at probable at most, whatever ts.roots_complete says`,
+        };
+        return [site, note] as const;
+      }),
+    ).values(),
+  ];
+}
+
 /** Each project the run dropped as a report names it, by its configuration file below the target. */
 function notBuiltOf(dropped: readonly NotBuilt[], targetRoot: string): readonly ReportNotBuilt[] {
   return dropped.map((one) => {
@@ -309,7 +331,11 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
       typeErrorSkips: run.typeErrorSkips,
       unanswered: unansweredCounts(analysis),
       conventionsApplied: run.conventionsApplied,
-      notes: unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+      listsComponents: config.reporters.cascade === "full",
+      notes: [
+        ...unmappedNotes(run.unmappedEntries, resolvePath(invoked, targetRoot)),
+        ...unseenLoadNotes(run.unseenLoads),
+      ],
     });
     report = capFindings(sortFindings(built, config.reporters.sort), config.reporters.maxFindings);
     verdict = verdictOf(result, config);
@@ -324,7 +350,6 @@ export const analyzeVerb: Verb = ({ err, host, inputs, scope, openClient, option
   try {
     host.writeDocument(documents.report, json(report));
     const options = {
-      failOn: config.reporters.failOn,
       readSource: (path: string) => host.readFile(joinPath(targetRoot, path)),
       template,
     };

package/src/workflow-steps.ts

@@ -97,12 +97,11 @@ export function runCommands(text: string, key: RegExp = RUN_LINE): readonly stri
 }
 
 /**
- * Every token the recipe lines of the target root's makefile hold, each with the directory
- * below the root it is read against: a recipe line is one that starts with a tab, joined
- * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
- * own, so a `cd` moves the directory of the later commands of its line alone.
+ * The commands of the recipe lines of the target root's makefile, each line's in order: a
+ * recipe line is one that starts with a tab, joined with the lines a trailing `\`
+ * continues it onto.
  */
-function recipeTokens(host: Host, root: string): readonly { token: string; dir: string }[] {
+function recipeLines(host: Host, root: string): readonly (readonly string[])[] {
   const path = MAKEFILES.map((name) => joinPath(root, name)).find(
     (candidate) => host.kindOf(candidate) === "file",
   );
@@ -110,15 +109,23 @@ function recipeTokens(host: Host, root: string): readonly { token: string; dir:
   if (text === undefined) {
     return [];
   }
+  return text
+    .replace(/\\\r?\n/gu, " ")
+    .split(/\r?\n/u)
+    .filter((line) => line.startsWith("\t"))
+    .map((line) => withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(COMMAND_SEPARATORS));
+}
+
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: make runs each line in a shell of its own, so a `cd`
+ * moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host: Host, root: string): readonly { token: string; dir: string }[] {
   const found: { token: string; dir: string }[] = [];
-  for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
-    if (!line.startsWith("\t")) {
-      continue;
-    }
+  for (const line of recipeLines(host, root)) {
     let dir = root;
-    for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(
-      COMMAND_SEPARATORS,
-    )) {
+    for (const command of line) {
       const tokens = scriptTokens(command);
       const [first, target, ...rest] = tokens;
       if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
@@ -156,13 +163,27 @@ function withoutComment(line: string): string {
 }
 
 /**
- * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
+ * Every command the target root's workflow steps, git hooks and makefile run: the `run:`
  * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
  * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
  * of a lefthook file and the makefile's recipe lines.
  */
+export function workflowCommands(host: Host, targetRoot: string): readonly string[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return [...stepCommands(host, root), ...recipeLines(host, root).flat()];
+}
+
+/** Every token the commands {@link workflowCommands} reads hold. */
 export function workflowTokens(host: Host, targetRoot: string): readonly string[] {
   const root = resolvePath(host.workingDirectory(), targetRoot);
+  return [
+    ...stepCommands(host, root).flatMap((command) => scriptTokens(command)),
+    ...recipeTokens(host, root).map(({ token }) => token),
+  ];
+}
+
+/** The commands of the workflow steps, git hooks and hook managers at one root. */
+function stepCommands(host: Host, root: string): readonly string[] {
   const commands: string[] = [];
   for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
     commands.push(...runCommands(readText(host, path) ?? ""));
@@ -175,10 +196,7 @@ export function workflowTokens(host: Host, targetRoot: string): readonly string[
   for (const [name, key] of HOOK_MANAGERS) {
     commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
   }
-  return [
-    ...commands.flatMap((command) => scriptTokens(command)),
-    ...recipeTokens(host, root).map(({ token }) => token),
-  ];
+  return commands;
 }
 
 /**