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

package/src/{conventions.ts → entries/conventions.ts}

@@ -6,46 +6,8 @@
  * No configuration file is run.
  */
 
-import {
-  isArrayLiteralExpression,
-  isAsExpression,
-  isBinaryExpression,
-  isCallExpression,
-  isClassDeclaration,
-  isComputedPropertyName,
-  isExportAssignment,
-  isExportDeclaration,
-  isExpressionStatement,
-  isFunctionDeclaration,
-  isIdentifier,
-  isImportDeclaration,
-  isNamedExports,
-  isNamespaceImport,
-  isNoSubstitutionTemplateLiteral,
-  isNonNullExpression,
-  isNumericLiteral,
-  isObjectBindingPattern,
-  isObjectLiteralExpression,
-  isParenthesizedExpression,
-  isPropertyAccessExpression,
-  isPropertyAssignment,
-  isSatisfiesExpression,
-  isShorthandPropertyAssignment,
-  isSpreadAssignment,
-  isStringLiteral,
-  isVariableStatement,
-  SyntaxKind,
-  type AsExpression,
-  type Identifier,
-  type Node,
-  type ObjectBindingPattern,
-  type NonNullExpression,
-  type ObjectLiteralExpression,
-  type ParenthesizedExpression,
-  type SatisfiesExpression,
-  type SourceFile,
-} from "@typescript/native/ast";
-import { lineOf } from "./component-files.ts";
+import type { SourceFile } from "@typescript/native/ast";
+import { lineOf } from "../component-files.ts";
 import {
   CONVENTION_ROWS,
   type ConventionRow,
@@ -57,15 +19,41 @@ import {
   type PackageKey,
   type PrefixedNameReading,
   type ShortNameReading,
+  type TestDirectoryReading,
   type TestFileReading,
 } from "./convention-rows.ts";
 import { documentStrings } from "./configuration-files.ts";
-import { globExpression } from "./glob.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.ts";
-import type { SetupFailure } from "./setup-failure.ts";
-import type { SourceFiles } from "./source-files.ts";
-import { satisfies } from "./version-range.ts";
+import { readCommands, type CommandReading } from "../commands/read.ts";
+import { nodeTestGlobs, type RunnerInput, type TestGlob } from "./test-runners.ts";
+import {
+  documentModule,
+  membersNamed,
+  staticModule,
+  textsOf,
+  valuesAt,
+  type StaticModule,
+  type Value,
+} from "./static-module.ts";
+import type { Host } from "../host.ts";
+import {
+  ancestors,
+  cannotStartPackageName,
+  dirnamePath,
+  joinPath,
+  normalizePath,
+  relativePath,
+  resolvePath,
+} from "../paths.ts";
+import type { Failure } from "../failure.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { satisfies } from "../version-range.ts";
+import { bytewise } from "../text/compare.ts";
+import { isRecord } from "../json-document.ts";
+import { filesIn } from "../fs/tree.ts";
+import { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, MANIFEST, readJSON } from "../fs/manifest.ts";
+import { globExpression } from "../text/glob.ts";
+import { yamlDocument } from "../text/yaml.ts";
+import { APPENDED_EXTENSIONS, braced } from "../extensions.ts";
 
 /** One manifest the analysis reads. */
 export interface ConventionManifest {
@@ -110,7 +98,7 @@ interface GeneratedDirectory {
 /** A setup failure a row met, at the directory of the manifest that declared it. */
 interface ConventionFailure {
   readonly dir: string;
-  readonly failure: SetupFailure;
+  readonly failure: Failure;
 }
 
 /** What the rows decided for one run. */
@@ -127,8 +115,10 @@ export interface Conventions {
   readonly uses: readonly string[];
   /** Per configuration file, absolute, the strings its applied rows' selection keys hold. */
   readonly selected: ReadonlyMap<string, Selected>;
-  /** The files, absolute, an applied row's test-file properties name. */
-  readonly testFiles: ReadonlySet<string>;
+  /** The files, absolute, an applied row's test-file properties name, each with the string naming it. */
+  readonly testFiles: ReadonlyMap<string, string>;
+  /** The test-file patterns of the applied rows' test directory readings. */
+  readonly testGlobs: readonly TestGlob[];
 }
 
 /** The strings one configuration file holds at selection keys, which root no file. */
@@ -149,32 +139,15 @@ interface ConventionEntry {
 /** Parses one file's text with no program. */
 type ParseSource = (fileName: string, text: string) => SourceFile;
 
-const JSON_EXTENSION = ".json";
+/** A configuration file its tool reads as a YAML document. */
+const YAML_NAME = /\.ya?ml$/u;
 
-/** A configuration file with no extension that its tool reads as a JSON document. */
-const JSON_RC = /^\.[\w-]+rc$/u;
+/** A configuration file its tool reads as a JSON document whose name does not end with `.json`. */
+const JSON_NAME = /^\.[\w-]+rc$|\.jsonc$/u;
 
 /** The sections an installed package is required by, so its absence fails the run. */
 const REQUIRED_SECTIONS = ["dependencies", "devDependencies"] as const;
 
-const DEPENDENCY_SECTIONS = [
-  ...REQUIRED_SECTIONS,
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readJSON(host: Host, path: string): unknown {
-  try {
-    return JSON.parse(host.readFile(path));
-  } catch {
-    return undefined;
-  }
-}
-
 function declares(
   manifest: unknown,
   name: string,
@@ -195,353 +168,59 @@ function declares(
  * none, or `undefined` where no `node_modules` holds it.
  */
 function installedVersion(host: Host, dir: string, name: string): string | undefined {
-  for (let at = normalizePath(dir); ; at = dirnamePath(at)) {
-    const path = joinPath(at, "node_modules", name, "package.json");
+  for (const at of ancestors(dir)) {
+    const path = joinPath(at, INSTALLED_PACKAGES, name, MANIFEST);
     if (host.kindOf(path) === "file") {
       const manifest = readJSON(host, path);
       const version = isRecord(manifest) ? manifest["version"] : undefined;
       return typeof version === "string" ? version : "";
     }
-    if (dirnamePath(at) === at) {
-      return undefined;
-    }
-  }
-}
-
-/** Whether one node wraps an expression without changing its value. */
-function isWrapper(
-  node: Node,
-): node is ParenthesizedExpression | AsExpression | SatisfiesExpression | NonNullExpression {
-  return (
-    isParenthesizedExpression(node) ||
-    isAsExpression(node) ||
-    isSatisfiesExpression(node) ||
-    isNonNullExpression(node)
-  );
-}
-
-/** The expression a wrapper that changes no value holds. */
-function unwrapped(node: Node): Node {
-  let at = node;
-  while (isWrapper(at)) {
-    at = at.expression;
-  }
-  return at;
-}
-
-/** The key one property is written with, where it is written as a name or as literal text. */
-function keyOf(property: Node): string | undefined {
-  if (!isPropertyAssignment(property) && !isShorthandPropertyAssignment(property)) {
-    return undefined;
-  }
-  const { name } = property;
-  const key = isComputedPropertyName(name) ? name.expression : name;
-  if (
-    (isIdentifier(key) && key === name) ||
-    isStringLiteral(key) ||
-    isNoSubstitutionTemplateLiteral(key)
-  ) {
-    return key.text;
   }
   return undefined;
 }
 
-/** Whether one member's computed name is no literal, so it may set any key. */
-function computesKey(member: Node): boolean {
-  const name = (member as { readonly name?: Node }).name;
-  if (name === undefined || !isComputedPropertyName(name)) {
-    return false;
-  }
-  const key = name.expression;
-  return !(isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key));
+/** The objects a reading reads in one configuration file: each named call's options, or the default export. */
+function readObjects(module: StaticModule, call: OptionsCall | undefined): readonly Value[] {
+  return call === undefined ? module.defaultExport : module.options(call.module, call.export);
 }
 
-/** The values one file's top-level variable declarations bind, by name. */
-function declaredValues(file: SourceFile): ReadonlyMap<string, Node> {
-  const values = new Map<string, Node>();
-  for (const statement of file.statements) {
-    if (isVariableStatement(statement)) {
-      for (const declaration of statement.declarationList.declarations) {
-        if (isIdentifier(declaration.name) && declaration.initializer !== undefined) {
-          values.set(declaration.name.text, declaration.initializer);
-        }
-      }
-    }
-  }
-  return values;
-}
-
-function isModuleExports(node: Node): boolean {
-  return (
-    isPropertyAccessExpression(node) &&
-    isIdentifier(node.expression) &&
-    node.expression.text === "module" &&
-    node.name.text === "exports"
-  );
+/** Where a value that a reading cannot take as a literal is written, undefined in a document with no positions. */
+interface NotLiteral {
+  readonly at: number | undefined;
 }
 
 /**
- * Every expression or declaration one file exports as its default, in any module syntax.
- * A JSON module's default export is its document's value.
- */
-function defaultExports(file: SourceFile): readonly Node[] {
-  if (file.fileName.endsWith(JSON_EXTENSION)) {
-    return file.statements.flatMap((statement) =>
-      isExpressionStatement(statement) ? [statement.expression] : [],
-    );
-  }
-  const found: Node[] = [];
-  for (const statement of file.statements) {
-    if (isExportAssignment(statement)) {
-      found.push(statement.expression);
-    } else if (
-      (isFunctionDeclaration(statement) || isClassDeclaration(statement)) &&
-      statement.modifiers?.some((one) => one.kind === SyntaxKind.DefaultKeyword) === true
-    ) {
-      found.push(statement);
-    } else if (
-      isExportDeclaration(statement) &&
-      statement.moduleSpecifier === undefined &&
-      statement.exportClause !== undefined &&
-      isNamedExports(statement.exportClause)
-    ) {
-      for (const element of statement.exportClause.elements) {
-        if (element.name.text === "default") {
-          found.push(element.propertyName ?? element.name);
-        }
-      }
-    } else if (
-      isExpressionStatement(statement) &&
-      isBinaryExpression(statement.expression) &&
-      statement.expression.operatorToken.kind === SyntaxKind.EqualsToken &&
-      isModuleExports(statement.expression.left)
-    ) {
-      found.push(statement.expression.right);
-    }
-  }
-  return found;
-}
-
-/** The declarations whose name is a binding of the scope they are written in. */
-const BINDING_KINDS: ReadonlySet<SyntaxKind> = new Set([
-  SyntaxKind.VariableDeclaration,
-  SyntaxKind.Parameter,
-  SyntaxKind.BindingElement,
-  SyntaxKind.FunctionDeclaration,
-  SyntaxKind.ClassDeclaration,
-  SyntaxKind.ImportClause,
-  SyntaxKind.ImportSpecifier,
-  SyntaxKind.NamespaceImport,
-  SyntaxKind.ImportEqualsDeclaration,
-]);
-
-/** Whether one file declares a binding named `require` at any depth, which shadows the global. */
-function declaresRequire(file: SourceFile): boolean {
-  let found = false;
-  const visit = (node: Node): void => {
-    const name = (node as { readonly name?: Node }).name;
-    if (
-      name !== undefined &&
-      isIdentifier(name) &&
-      name.text === "require" &&
-      BINDING_KINDS.has(node.kind)
-    ) {
-      found = true;
-    }
-    if (!found) {
-      node.forEachChild(visit);
-    }
-  };
-  file.forEachChild(visit);
-  return found;
-}
-
-/**
- * The top-level `const`, `let` and `var` declarations that bind a `require` of one module,
- * written with the module's name as its one string-literal argument, in a file that
- * declares no binding named `require`: each binds as an import of the module does.
- */
-function requireBindings(
-  file: SourceFile,
-  module: string,
-): readonly (Identifier | ObjectBindingPattern)[] {
-  const found: (Identifier | ObjectBindingPattern)[] = [];
-  for (const statement of file.statements) {
-    if (!isVariableStatement(statement)) {
-      continue;
-    }
-    for (const declaration of statement.declarationList.declarations) {
-      const value =
-        declaration.initializer === undefined ? undefined : unwrapped(declaration.initializer);
-      const [argument, ...rest] =
-        value !== undefined && isCallExpression(value) ? value.arguments : [];
-      if (
-        value === undefined ||
-        !isCallExpression(value) ||
-        !isIdentifier(value.expression) ||
-        value.expression.text !== "require" ||
-        argument === undefined ||
-        rest.length > 0 ||
-        !isStringLiteral(argument) ||
-        argument.text !== module
-      ) {
-        continue;
-      }
-      if (isIdentifier(declaration.name) || isObjectBindingPattern(declaration.name)) {
-        found.push(declaration.name);
-      }
-    }
-  }
-  return found.length > 0 && declaresRequire(file) ? [] : found;
-}
-
-/**
- * The first argument of every call one file makes to one module's export, through a
- * named or a namespace import; `undefined` for a call with no argument.
- */
-function optionsArguments(file: SourceFile, call: OptionsCall): readonly (Node | undefined)[] {
-  const names = new Set<string>();
-  const namespaces = new Set<string>();
-  for (const name of requireBindings(file, call.module)) {
-    if (isIdentifier(name)) {
-      namespaces.add(name.text);
-      continue;
-    }
-    for (const element of name.elements) {
-      const local = element.name;
-      const exported = element.propertyName ?? local;
-      if (
-        element.dotDotDotToken === undefined &&
-        local !== undefined &&
-        isIdentifier(local) &&
-        exported !== undefined &&
-        (isIdentifier(exported) || isStringLiteral(exported)) &&
-        exported.text === call.export
-      ) {
-        names.add(local.text);
-      }
-    }
-  }
-  for (const statement of file.statements) {
-    const bindings = isImportDeclaration(statement)
-      ? statement.importClause?.namedBindings
-      : undefined;
-    if (
-      bindings === undefined ||
-      !isImportDeclaration(statement) ||
-      !isStringLiteral(statement.moduleSpecifier) ||
-      statement.moduleSpecifier.text !== call.module
-    ) {
-      continue;
-    }
-    if (isNamespaceImport(bindings)) {
-      namespaces.add(bindings.name.text);
-      continue;
-    }
-    for (const element of bindings.elements) {
-      if ((element.propertyName ?? element.name).text === call.export) {
-        names.add(element.name.text);
-      }
-    }
-  }
-  const found: (Node | undefined)[] = [];
-  const visit = (node: Node): void => {
-    if (isCallExpression(node)) {
-      const callee = unwrapped(node.expression);
-      const named = isIdentifier(callee) && names.has(callee.text);
-      const throughNamespace =
-        isPropertyAccessExpression(callee) &&
-        isIdentifier(callee.expression) &&
-        namespaces.has(callee.expression.text) &&
-        callee.name.text === call.export;
-      if (named || throughNamespace) {
-        found.push(node.arguments[0]);
-      }
-    }
-    node.forEachChild(visit);
-  };
-  file.forEachChild(visit);
-  return found;
-}
-
-/**
- * The object literal one expression stands for, read through the file's top-level
- * declarations and, where `throughCalls`, through a call's first argument: `undefined`
- * for a call with no argument, and any other node where the expression is not written
- * out as an object literal.
- */
-function objectOf(
-  node: Node,
-  declared: ReadonlyMap<string, Node>,
-  throughCalls: boolean,
-  seen: ReadonlySet<string> = new Set(),
-): Node | undefined {
-  const at = unwrapped(node);
-  if (isIdentifier(at)) {
-    const value = declared.get(at.text);
-    if (value !== undefined && !seen.has(at.text)) {
-      return objectOf(value, declared, throughCalls, new Set([...seen, at.text]));
-    }
-  } else if (throughCalls && isCallExpression(at)) {
-    const [first] = at.arguments;
-    return first === undefined ? undefined : objectOf(first, declared, throughCalls, seen);
-  }
-  return at;
-}
-
-/** The text of a string literal or a template literal with no substitution, or undefined. */
-function literalText(node: Node): string | undefined {
-  const at = unwrapped(node);
-  return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
-}
-
-/**
- * The literal texts one value at a path's end writes: the literal itself, or, where
- * `elements`, each element of an array literal of literals. Undefined for any other value.
- */
-function literalTexts(held: Node, elements: boolean): readonly string[] | undefined {
-  const one = literalText(held);
-  if (one !== undefined) {
-    return [one];
-  }
-  if (!elements || !isArrayLiteralExpression(held)) {
-    return undefined;
-  }
-  const texts = held.elements.map(literalText);
-  return texts.every((text) => text !== undefined) ? texts : undefined;
-}
-
-/**
- * Reads the values at one path of keys below one object literal into `values`, and
- * answers the first member that does not write its value out: a spread, a value that is
- * not a literal at the path's end, or one that is not an object literal before it.
+ * Reads the values at one path of keys below one object into `values`, and answers the
+ * first place that does not write its value out: an object that is no object literal, a
+ * spread or a computed key, a value at the path's end that is no literal, or one before
+ * it that is no object literal.
  */
 function readPath(
-  object: ObjectLiteralExpression,
+  object: Value,
   keys: readonly string[],
   values: string[],
   elements: boolean,
-): Node | undefined {
+): NotLiteral | undefined {
+  if (object.kind !== "object") {
+    return object;
+  }
   const [key, ...rest] = keys;
-  for (const member of object.properties) {
-    if (isSpreadAssignment(member) || computesKey(member)) {
+  for (const member of object.members) {
+    if (member.key === undefined) {
       return member;
     }
-    if (keyOf(member) !== key) {
+    if (member.key !== key) {
       continue;
     }
-    const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
     if (rest.length === 0) {
-      const texts = held === undefined ? undefined : literalTexts(held, elements);
+      const texts = textsOf(member.value, elements);
       if (texts === undefined) {
         return member;
       }
       values.push(...texts);
     } else {
-      if (held === undefined || !isObjectLiteralExpression(held)) {
-        return member;
-      }
-      const failed = readPath(held, rest, values, elements);
+      const failed =
+        member.value.kind === "object" ? readPath(member.value, rest, values, elements) : member;
       if (failed !== undefined) {
         return failed;
       }
@@ -550,80 +229,45 @@ function readPath(
   return undefined;
 }
 
-/**
- * Every value one file writes at one property's path inside the objects it is read from,
- * as {@link readProperty} reads them, whatever else the path holds.
- */
-function valuesAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
-  const declared = declaredValues(file);
-  const objects =
-    call === undefined
-      ? defaultExports(file).map((one) => objectOf(one, declared, true))
-      : optionsArguments(file, call).map((one) =>
-          one === undefined ? undefined : objectOf(one, declared, false),
-        );
-  const found: Node[] = [];
-  const visit = (object: Node, keys: readonly string[]): void => {
-    if (!isObjectLiteralExpression(object)) {
-      return;
-    }
-    const [key, ...rest] = keys;
-    for (const member of object.properties) {
-      if (!isPropertyAssignment(member) || keyOf(member) !== key) {
-        continue;
-      }
-      const held = unwrapped(member.initializer);
-      if (rest.length > 0) {
-        visit(held, rest);
-      } else {
-        found.push(held);
-      }
-    }
-  };
-  for (const object of objects) {
-    if (object !== undefined) {
-      visit(object, property.split("."));
-    }
-  }
-  return found;
-}
-
-/** The string literals among values: each value itself, or each element of an array value. */
-function stringsAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
-  return valuesAt(file, property, call).flatMap((held) => {
-    if (literalText(held) !== undefined) {
-      return [held];
-    }
-    return isArrayLiteralExpression(held)
-      ? held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined)
-      : [];
-  });
+/** The text values among the values at one path: each value itself, or each element of an array value. */
+function stringsAt(
+  objects: readonly Value[],
+  property: string,
+): readonly { readonly text: string; readonly at: number | undefined }[] {
+  return valuesAt(objects, property.split(".")).flatMap((value) =>
+    (value.kind === "array" ? value.elements : [value]).flatMap((one) =>
+      one.kind === "text" ? [one] : [],
+    ),
+  );
 }
 
 /** Whether one value holds a helper setting's value, as {@link HelperReading} states it. */
-function holdsValue(held: Node, value: true | string): boolean {
+function holdsValue(held: Value, value: true | string): boolean {
   if (value === true) {
-    return held.kind === SyntaxKind.TrueKeyword;
+    return held.kind === "boolean" && held.value;
   }
-  if (literalText(held) === value) {
-    return true;
+  if (held.kind === "text") {
+    return held.text === value;
   }
   return (
-    isArrayLiteralExpression(held) &&
+    held.kind === "array" &&
     held.elements.some((element) => {
-      const one = unwrapped(element);
-      const first = isArrayLiteralExpression(one) ? one.elements[0] : one;
-      return first !== undefined && literalText(first) === value;
+      const first = element.kind === "array" ? element.elements[0] : element;
+      return first?.kind === "text" && first.text === value;
     })
   );
 }
 
-/** The directory one file's test-file strings are read against, as {@link TestFileReading} states it. */
-function testFileRoot(file: SourceFile, dir: string, reading: TestFileReading): string | undefined {
-  for (const property of reading.roots) {
-    const values = valuesAt(file, property, reading.call);
+/** The directory one group of objects' test-file strings are read against, as {@link TestFileReading} states it. */
+function testFileRoot(
+  objects: readonly Value[],
+  dir: string,
+  roots: readonly string[],
+): string | undefined {
+  for (const property of roots) {
+    const values = valuesAt(objects, property.split("."));
     if (values.length > 0) {
-      const texts = new Set(values.map(literalText));
+      const texts = new Set(values.map((one) => (one.kind === "text" ? one.text : undefined)));
       const [text] = texts;
       return texts.size === 1 && text !== undefined ? resolvePath(dir, text) : undefined;
     }
@@ -631,45 +275,146 @@ function testFileRoot(file: SourceFile, dir: string, reading: TestFileReading):
   return dir;
 }
 
-/** The files an applied row's test-file properties name. */
+/**
+ * The files an applied row's test-file properties name, each string also added to
+ * `selected`, since a test file is rooted by no configuration string (conventions.11). A
+ * property's path up to its last `*` selects objects that each resolve their strings
+ * against their own roots.
+ */
 function testFilesNamed(
-  host: Host,
-  parse: ParseSource,
+  read: ReadFiles,
   dir: string,
   readings: readonly TestFileReading[],
-  into: Set<string>,
+  into: Map<string, string>,
+  selected: Map<string, { starts: Set<number>; texts: string[] }>,
 ): void {
   for (const reading of readings) {
-    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
-      const at = testFileRoot(file, dir, reading);
-      if (at === undefined) {
-        continue;
+    const star = reading.property.lastIndexOf("*.");
+    const each = star < 0 ? undefined : reading.property.slice(0, star + 1).split(".");
+    const property = star < 0 ? reading.property : reading.property.slice(star + 2);
+    for (const { name, module } of read(dir, reading.files)) {
+      const path = joinPath(dir, name);
+      const held = selected.get(path) ?? { starts: new Set<number>(), texts: [] };
+      selected.set(path, held);
+      const objects = readObjects(module, reading.call);
+      const groups = each === undefined ? [objects] : valuesAt(objects, each).map((one) => [one]);
+      for (const group of groups) {
+        const at = testFileRoot(group, dir, reading.roots);
+        if (at === undefined) {
+          continue;
+        }
+        for (const { text, at: start } of stringsAt(group, property)) {
+          if (start !== undefined) {
+            held.starts.add(start);
+          }
+          held.texts.push(text);
+          if (text !== "") {
+            into.set(resolvePath(at, text), text);
+          }
+        }
       }
-      for (const node of stringsAt(file, reading.property, reading.call)) {
-        const text = literalText(node);
-        if (text !== undefined && text !== "") {
-          into.add(resolvePath(at, text));
+    }
+  }
+}
+
+/** The directory and patterns one configuration object's tests are read from, undefined where its text does not state them. */
+interface TestDirectory {
+  readonly directory: string;
+  readonly patterns: readonly string[];
+}
+
+/** The one value an object's last write of a key gives, `null` where it writes none, undefined where it may hide one. */
+function lastMember(object: Value, key: string): Value | null | undefined {
+  const values = membersNamed(object, key);
+  return values === undefined ? undefined : (values.at(-1) ?? null);
+}
+
+/** The test directory one object states, each member it does not write taken from `inherited`. */
+function testDirectoryOf(
+  object: Value,
+  reading: TestDirectoryReading,
+  inherited: TestDirectory,
+): TestDirectory | undefined {
+  if (object.kind !== "object") {
+    return undefined;
+  }
+  const directory = lastMember(object, reading.directory);
+  const match = lastMember(object, reading.match);
+  if (directory === undefined || match === undefined) {
+    return undefined;
+  }
+  const dirs = directory === null ? [inherited.directory] : textsOf(directory, false);
+  const patterns = match === null ? inherited.patterns : textsOf(match, true);
+  const [one] = dirs ?? [];
+  return one === undefined || patterns === undefined ? undefined : { directory: one, patterns };
+}
+
+/**
+ * The test-file patterns an applied row's test directory readings give: each configuration
+ * object's own, or, where it lists projects, each project's, a member a project does not
+ * write taken from the configuration. An object whose text does not state them gives none.
+ */
+function testDirectoryGlobs(
+  read: ReadFiles,
+  dir: string,
+  readings: readonly TestDirectoryReading[],
+  into: TestGlob[],
+): void {
+  for (const reading of readings) {
+    const base = { directory: ".", patterns: [reading.defaultMatch] };
+    for (const { module } of read(dir, reading.files)) {
+      for (const config of module.defaultExport) {
+        const top = testDirectoryOf(config, reading, base);
+        const projects = lastMember(config, reading.projects);
+        if (top === undefined || projects === undefined) {
+          continue;
+        }
+        const listed =
+          projects === null ? [] : projects.kind === "array" ? projects.elements : [projects];
+        const each =
+          listed.length === 0 ? [top] : listed.map((one) => testDirectoryOf(one, reading, top));
+        for (const found of each) {
+          for (const pattern of found?.patterns ?? []) {
+            const expression = anywhereBelow(pattern);
+            into.push({
+              dir: resolvePath(dir, found?.directory ?? "."),
+              pattern,
+              matches: (name) => expression.test(name.replace(/^\/+/u, "")),
+            });
+          }
         }
       }
     }
   }
 }
 
+/**
+ * The expression a test-file pattern denotes over a file's whole path, as Playwright's
+ * matcher reads it: a pattern gains a leading `**` segment unless it starts with one, and
+ * case is not compared (https://github.com/microsoft/playwright/blob/main/packages/playwright/src/util.ts,
+ * `createFileMatcher`).
+ */
+function anywhereBelow(pattern: string): RegExp {
+  const expression = globExpression(pattern.startsWith("**/") ? pattern : `**/${pattern}`);
+  return new RegExp(expression.source, "iu");
+}
+
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(
-  host: Host,
-  parse: ParseSource,
+  read: ReadFiles,
   dir: string,
   readings: readonly MoveReading[],
   into: Map<string, { starts: Set<number>; texts: string[] }>,
 ): void {
   for (const reading of readings) {
-    for (const { name, file } of readingFiles(host, parse, dir, reading.files)) {
+    for (const { name, module } of read(dir, reading.files)) {
       const path = joinPath(dir, name);
       const held = into.get(path) ?? { starts: new Set<number>(), texts: [] };
-      for (const node of stringsAt(file, reading.property, reading.call)) {
-        held.starts.add(node.getStart());
-        held.texts.push(literalText(node) ?? "");
+      for (const { text, at } of stringsAt(readObjects(module, reading.call), reading.property)) {
+        if (at !== undefined) {
+          held.starts.add(at);
+        }
+        held.texts.push(text);
       }
       into.set(path, held);
     }
@@ -695,7 +440,7 @@ function manifestKeyUses(manifest: unknown, keys: readonly string[]): readonly s
 }
 
 /** The extensions an entry a manifest entry key names without one may carry. */
-const ENTRY_EXTENSIONS = "{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+const ENTRY_EXTENSIONS = braced(APPENDED_EXTENSIONS);
 
 /** The characters that make a manifest string a pattern rather than a directory's name. */
 const PATTERN = /[*?{}[\]]/u;
@@ -739,12 +484,12 @@ function manifestEntryGlobs(manifest: unknown, keys: readonly ManifestEntryKey[]
 interface PropertyReading {
   /** The literal values the file sets the property to. */
   readonly values: readonly string[];
-  /** The position of the first value that is not a literal, where there is one. */
-  readonly notLiteral?: Node;
+  /** Where the first value that is not a literal is written, where there is one. */
+  readonly notLiteral?: NotLiteral;
 }
 
 /**
- * Every value one file writes at one property's path inside the object it is read from:
+ * Every value one file writes at one property's path inside the objects it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
  * literal or a template literal with no substitution is the value, and so is each element
  * of an array literal of them where `elements`. A read object, or an object along the
@@ -752,26 +497,14 @@ interface PropertyReading {
  * itself, is not a literal, and neither is any other value at the path.
  */
 export function readProperty(
-  file: SourceFile,
+  module: StaticModule,
   property: string,
   call?: OptionsCall,
   elements = false,
 ): PropertyReading {
-  const declared = declaredValues(file);
-  const objects =
-    call === undefined
-      ? defaultExports(file).map((one) => objectOf(one, declared, true))
-      : optionsArguments(file, call).map((one) =>
-          one === undefined ? undefined : objectOf(one, declared, false),
-        );
   const values: string[] = [];
-  for (const object of objects) {
-    if (object === undefined) {
-      continue;
-    }
-    const notLiteral = isObjectLiteralExpression(object)
-      ? readPath(object, property.split("."), values, elements)
-      : object;
+  for (const object of readObjects(module, call)) {
+    const notLiteral = readPath(object, property.split("."), values, elements);
     if (notLiteral !== undefined) {
       return { values, notLiteral };
     }
@@ -815,24 +548,14 @@ function expand(
 /** The configuration files in one directory that one glob names, by name. */
 function configurationFiles(host: Host, dir: string, glob: string): readonly string[] {
   const expression = globExpression(glob);
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((entry) => !entry.directory && expression.test(entry.name))
-    .map((entry) => entry.name)
-    .sort();
+  return filesIn(host, dir, (name) => expression.test(name));
 }
 
 /** What one move resolved to: its directories, or the failure its property met. */
 type MoveResult = { readonly dirs: readonly (string | undefined)[] } | { readonly failure: string };
 
 function resolveMove(
-  host: Host,
-  parse: ParseSource,
+  read: ReadFiles,
   dir: string,
   row: ConventionRow,
   move: DirectoryMove,
@@ -840,13 +563,14 @@ function resolveMove(
 ): MoveResult {
   const set: string[] = [];
   for (const reading of move.readings) {
-    for (const { name, text, file } of readingFiles(host, parse, dir, reading.files)) {
-      const read = readProperty(file, reading.property, reading.call);
+    for (const { name, text, module } of read(dir, reading.files)) {
+      const read = readProperty(module, reading.property, reading.call);
       if (read.notLiteral !== undefined) {
-        const line = lineOf(text, read.notLiteral.getStart());
+        const { at } = read.notLiteral;
+        const where = at === undefined ? name : `${name}:${String(lineOf(text, at))}`;
         return {
           failure:
-            `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
+            `${where} sets ${reading.property}, which moves a directory ` +
             `the convention row ${row.name} reads, to a value that is not a string literal: ` +
             `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
             `files in ts.entry_files`,
@@ -866,31 +590,44 @@ function resolveMove(
   return { dirs: [...new Set(dirs)] };
 }
 
-/** The texts each configuration file a reading names holds, parsed, in name order. */
-function readingFiles(
-  host: Host,
-  parse: ParseSource,
-  dir: string,
-  files: readonly string[],
-): readonly { readonly name: string; readonly text: string; readonly file: SourceFile }[] {
-  const found = [];
-  for (const glob of files) {
-    for (const name of configurationFiles(host, dir, glob)) {
-      const path = joinPath(dir, name);
-      let text: string;
-      try {
-        text = host.readFile(path);
-      } catch {
-        continue;
+/** One configuration file a reading names, read as a static module. */
+interface ReadFile {
+  readonly name: string;
+  readonly text: string;
+  readonly module: StaticModule;
+}
+
+/** The configuration files in one directory a reading's globs name, in name order. */
+type ReadFiles = (dir: string, files: readonly string[]) => readonly ReadFile[];
+
+/** A reader that reads and parses each configuration file once for every row and reading of a run. */
+function readFilesOnce(host: Host, parse: ParseSource): ReadFiles {
+  const read = new Map<string, ReadFile | undefined>();
+  const readOne = (dir: string, name: string): ReadFile | undefined => {
+    const path = joinPath(dir, name);
+    if (read.has(path)) {
+      return read.get(path);
+    }
+    let found: ReadFile | undefined;
+    try {
+      const text = host.readFile(path);
+      if (YAML_NAME.test(name)) {
+        const value = yamlDocument(text);
+        found = value === undefined ? undefined : { name, text, module: documentModule(value) };
+      } else {
+        const file = parse(JSON_NAME.test(name) ? `${path}.json` : path, text);
+        found = { name, text, module: staticModule(file) };
       }
-      found.push({
-        name,
-        text,
-        file: parse(JSON_RC.test(name) ? `${path}${JSON_EXTENSION}` : path, text),
-      });
+    } catch {
+      found = undefined;
     }
-  }
-  return found;
+    read.set(path, found);
+    return found;
+  };
+  return (dir, files) =>
+    files.flatMap((glob) =>
+      configurationFiles(host, dir, glob).flatMap((name) => readOne(dir, name) ?? []),
+    );
 }
 
 /**
@@ -899,8 +636,7 @@ function readingFiles(
  * declared dependency the row's package name stands for with some value.
  */
 function shortNameUses(
-  host: Host,
-  parse: ParseSource,
+  read: ReadFiles,
   dir: string,
   manifest: unknown,
   readings: readonly ShortNameReading[],
@@ -914,8 +650,8 @@ function shortNameUses(
   const used = new Set<string>();
   for (const reading of readings) {
     const [before = "", after = ""] = reading.package.split("{}");
-    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
-      const read = readProperty(file, reading.property, reading.call, true);
+    for (const { module } of read(dir, reading.files)) {
+      const read = readProperty(module, reading.property, reading.call, true);
       for (const value of read.values) {
         used.add(`${before}${value}${after}`);
       }
@@ -932,7 +668,7 @@ function shortNameUses(
       }
     }
   }
-  return [...used].filter((name) => declared.has(name)).sort(compare);
+  return [...used].filter((name) => declared.has(name)).sort(bytewise);
 }
 
 /**
@@ -943,7 +679,7 @@ function prefixedPackage(value: string, reading: PrefixedNameReading): string |
   const { prefix, marker } = reading;
   let name: string;
   if (marker === undefined) {
-    if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
+    if (value.includes(":") || cannotStartPackageName(value)) {
       return undefined;
     }
     const parts = value.split("/");
@@ -969,8 +705,7 @@ function prefixedPackage(value: string, reading: PrefixedNameReading): string |
 
 /** The declared dependencies an applied row's prefixed names use. */
 function prefixedNameUses(
-  host: Host,
-  parse: ParseSource,
+  read: ReadFiles,
   dir: string,
   manifest: unknown,
   readings: readonly PrefixedNameReading[],
@@ -983,8 +718,8 @@ function prefixedNameUses(
   );
   const used = new Set<string>();
   for (const reading of readings) {
-    for (const { file } of readingFiles(host, parse, dir, reading.files)) {
-      for (const value of readProperty(file, reading.property, reading.call, true).values) {
+    for (const { module } of read(dir, reading.files)) {
+      for (const value of readProperty(module, reading.property, reading.call, true).values) {
         const named = prefixedPackage(value, reading);
         if (named !== undefined && declared.has(named)) {
           used.add(named);
@@ -992,13 +727,12 @@ function prefixedNameUses(
       }
     }
   }
-  return [...used].sort(compare);
+  return [...used].sort(bytewise);
 }
 
 /** The declared dependencies an applied row's helper settings use. */
 function helperUses(
-  host: Host,
-  parse: ParseSource,
+  read: ReadFiles,
   dir: string,
   manifest: unknown,
   readings: readonly HelperReading[],
@@ -1013,8 +747,8 @@ function helperUses(
     .filter(
       (reading) =>
         declared.has(reading.package) &&
-        readingFiles(host, parse, dir, reading.files).some(({ file }) =>
-          valuesAt(file, reading.property, reading.call).some((held) =>
+        read(dir, reading.files).some(({ module }) =>
+          valuesAt(readObjects(module, reading.call), reading.property.split(".")).some((held) =>
             holdsValue(held, reading.value),
           ),
         ),
@@ -1028,8 +762,7 @@ function helperUses(
  * by `:` and a name. A member's own name is no such string.
  */
 function packageKeyUses(
-  host: Host,
-  parse: ParseSource,
+  read: ReadFiles,
   dir: string,
   manifest: unknown,
   keys: readonly PackageKey[],
@@ -1039,31 +772,31 @@ function packageKeyUses(
     return isRecord(held) ? Object.keys(held) : [];
   });
   const strings: string[] = [];
-  const collect = (node: Node): void => {
-    const text = literalText(node);
-    if (text !== undefined) {
-      strings.push(text);
-    } else if (isPropertyAssignment(node)) {
-      collect(node.initializer);
-    } else {
-      node.forEachChild(collect);
+  const children = (value: Value): readonly Value[] =>
+    value.kind === "object"
+      ? value.members.map((member) => member.value)
+      : value.kind === "array"
+        ? value.elements
+        : [];
+  const collect = (value: Value): void => {
+    if (value.kind === "text") {
+      strings.push(value.text);
     }
+    children(value).forEach(collect);
   };
   for (const { key, files } of keys) {
-    const visit = (node: Node): void => {
-      if (isPropertyAssignment(node) && keyOf(node) === key) {
-        collect(node.initializer);
+    const visit = (value: Value): void => {
+      if (value.kind === "object") {
+        value.members
+          .filter((member) => member.key === key)
+          .forEach((member) => {
+            collect(member.value);
+          });
       }
-      node.forEachChild(visit);
+      children(value).forEach(visit);
     };
-    for (const { file } of readingFiles(host, parse, dir, files)) {
-      const values = declaredValues(file);
-      for (const one of defaultExports(file)) {
-        const object = objectOf(one, values, true);
-        if (object !== undefined) {
-          visit(object);
-        }
-      }
+    for (const { module } of read(dir, files)) {
+      module.defaultExport.forEach(visit);
     }
   }
   return declared.filter((name) =>
@@ -1076,12 +809,14 @@ function packageKeyUses(
   );
 }
 
-/** Two strings ordered bytewise. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
+/** What the command reader reads each of a manifest's `scripts` as, in the manifest's directory. */
+function scriptReadings(manifest: unknown, dir: string): readonly CommandReading[] {
+  const scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
+  return isRecord(scripts)
+    ? Object.values(scripts).flatMap((text) =>
+        typeof text === "string" ? [readCommands(text, dir)] : [],
+      )
+    : [];
 }
 
 /**
@@ -1101,9 +836,31 @@ export function readConventions(
   const failures: ConventionFailure[] = [];
   const uses = new Set<string>();
   const selected = new Map<string, { starts: Set<number>; texts: string[] }>();
-  const testFiles = new Set<string>();
+  const testFiles = new Map<string, string>();
+  const testGlobs: TestGlob[] = [];
+  const read = readFilesOnce(host, parse);
   for (const manifest of manifests) {
-    const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
+    const declared = readJSON(host, joinPath(manifest.dir, MANIFEST));
+    const scripts = scriptReadings(declared, manifest.dir);
+    let input: RunnerInput | undefined;
+    const runnerInput = (): RunnerInput => {
+      input ??= {
+        host,
+        dir: manifest.dir,
+        manifest: declared,
+        configuration: (dir, names) => {
+          for (const name of names) {
+            const [found] = read(dir, [name]);
+            if (found !== undefined) {
+              return { dir, module: found.module };
+            }
+          }
+          return undefined;
+        },
+        scripts: scripts.flatMap((one) => one.commands),
+      };
+      return input;
+    };
     const versions = new Map<string, string | undefined>();
     const missing = new Set<string>();
     for (const row of rows) {
@@ -1126,7 +883,7 @@ export function readConventions(
         failures.push({
           dir: manifest.dir,
           failure: {
-            setupClass: "missing-module",
+            failureClass: "missing-module",
             detail:
               `${manifest.path} declares ${row.package}, which no node_modules at or ` +
               `above its directory holds: run the package manager's install`,
@@ -1140,7 +897,7 @@ export function readConventions(
       const resolved = new Map<string, readonly (string | undefined)[]>();
       let failed: string | undefined;
       for (const move of row.moves) {
-        const result = resolveMove(host, parse, manifest.dir, row, move, resolved);
+        const result = resolveMove(read, manifest.dir, row, move, resolved);
         if ("failure" in result) {
           failed = result.failure;
           break;
@@ -1152,7 +909,7 @@ export function readConventions(
         failures.push({
           dir: manifest.dir,
           failure: {
-            setupClass: "convention-not-literal",
+            failureClass: "convention-not-literal",
             detail: where === "." ? failed : `${where}/${failed}`,
           },
         });
@@ -1164,25 +921,27 @@ export function readConventions(
         version,
         manifest: manifest.path,
       });
-      for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
+      for (const name of shortNameUses(read, manifest.dir, declared, row.shortNames ?? [])) {
         uses.add(name);
       }
       const prefixed = row.prefixedNames ?? [];
-      for (const name of prefixedNameUses(host, parse, manifest.dir, declared, prefixed)) {
+      for (const name of prefixedNameUses(read, manifest.dir, declared, prefixed)) {
         uses.add(name);
       }
       const keys = row.packageKeys ?? [];
-      for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
+      for (const name of packageKeyUses(read, manifest.dir, declared, keys)) {
         uses.add(name);
       }
       for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
         uses.add(name);
       }
-      for (const name of helperUses(host, parse, manifest.dir, declared, row.helpers ?? [])) {
+      for (const name of helperUses(read, manifest.dir, declared, row.helpers ?? [])) {
         uses.add(name);
       }
-      selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
-      testFilesNamed(host, parse, manifest.dir, row.testFiles ?? [], testFiles);
+      selectedStrings(read, manifest.dir, row.selections ?? [], selected);
+      testFilesNamed(read, manifest.dir, row.testFiles ?? [], testFiles, selected);
+      testDirectoryGlobs(read, manifest.dir, row.testDirectories ?? [], testGlobs);
+      testGlobs.push(...(row.testRunner?.(runnerInput()) ?? []));
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
       ].map(globExpression);
@@ -1202,25 +961,50 @@ export function readConventions(
         });
       }
     }
+    testGlobs.push(...nodeTestGlobs(scripts.flatMap((one) => one.tests)));
   }
   const unique = [...new Map(applied.map((one) => [JSON.stringify(one), one])).values()];
   unique.sort(
     (a, b) =>
-      compare(a.name, b.name) ||
-      compare(a.manifest, b.manifest) ||
-      compare(JSON.stringify(a), JSON.stringify(b)),
+      bytewise(a.name, b.name) ||
+      bytewise(a.manifest, b.manifest) ||
+      bytewise(JSON.stringify(a), JSON.stringify(b)),
   );
   return {
     applied: unique,
     globs,
     generated,
     failures,
-    uses: [...uses].sort(compare),
+    uses: [...uses].sort(bytewise),
     selected,
     testFiles,
+    testGlobs,
   };
 }
 
+/**
+ * The files, absolute, of one project an applied row names as test files, each with the
+ * string or the pattern that names it.
+ */
+export function conventionTestFiles(
+  conventions: Conventions,
+  files: SourceFiles,
+): ReadonlyMap<string, string> {
+  const found = new Map(conventions.testFiles);
+  for (const { dir, pattern, matches } of conventions.testGlobs) {
+    for (const file of files.byName.values()) {
+      if (
+        relativePath(dir, file.fileName) !== undefined &&
+        matches(file.fileName) &&
+        !found.has(file.fileName)
+      ) {
+        found.set(file.fileName, pattern);
+      }
+    }
+  }
+  return found;
+}
+
 /**
  * Every own file of one project below a directory an applied row names as generated, by
  * its path below the target root, with the name of the first such row.
@@ -1273,7 +1057,7 @@ export function conventionFailuresFor(
   conventions: Conventions,
   configFile: string,
   ownFiles: readonly string[],
-): readonly SetupFailure[] {
+): readonly Failure[] {
   return conventions.failures
     .filter(
       ({ dir }) =>