@cplieger/deadset-ts 5.0.0 → 5.1.0

package/src/contextual-uses.ts

@@ -0,0 +1,354 @@
+/**
+ * The uses contextual types make of the target's members, which no name node resolves to.
+ * An object-literal property writes the member of its name on each constituent of the
+ * literal's contextual type that declares one. A value reaching a position typed by another
+ * object type reads each of its members that type declares, through array elements and
+ * function parameters and results too; a class instance there is the
+ * interface-satisfaction class's evidence instead.
+ */
+
+import {
+  isComputedPropertyName,
+  isGetAccessorDeclaration,
+  isIdentifier,
+  isMethodDeclaration,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral,
+  isObjectLiteralExpression,
+  isPropertyAssignment,
+  isSetAccessorDeclaration,
+  isShorthandPropertyAssignment,
+  isStringLiteral,
+  type Expression,
+  type Node,
+  type ObjectLiteralExpression,
+} from "@typescript/native/unstable/ast";
+import { SignatureKind, type Type } from "@typescript/native/unstable/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import type { Inventory, SymbolKind } from "./inventory.ts";
+import { isAnswered, type PropertyTables } from "./query.ts";
+import type { ProjectView } from "./session.ts";
+
+/** The member kinds a contextual type writes and reads: data members and the members of object types. */
+const MEMBER_KINDS: ReadonlySet<SymbolKind> = new Set(["type-member", "class-member"]);
+
+/** One object literal a walk found, and the declaration it is written inside. */
+export interface LiteralAt {
+  readonly literal: ObjectLiteralExpression;
+  readonly from: string;
+}
+
+/** One value handed to a position typed by its context, and the declaration it is written inside. */
+export interface FlowAt {
+  readonly value: Expression;
+  readonly from: string;
+}
+
+/** One use the contextual types make: the node it is written at and the members it names. */
+export interface ContextualUse {
+  readonly at: Node;
+  readonly from: string;
+  readonly ids: readonly string[];
+}
+
+/** What the contextual types of one project's literals and values use, and what asking cost. */
+export interface ContextualUses {
+  /** Each literal property that writes a member, by the property's node. */
+  readonly writes: readonly ContextualUse[];
+  /** Each value whose members a position typed by another object type reads. */
+  readonly reads: readonly ContextualUse[];
+  /** The batched lookups: contextual types and value types, one per capped run. */
+  readonly batches: number;
+  /** The per-type lookups: each distinct type's constituents, properties and declaring symbol. */
+  readonly lookups: number;
+}
+
+/** The name one literal property is written under, where the name is literal text. */
+function propertyName(property: Node): { node: Node; text: string } | undefined {
+  if (
+    !isPropertyAssignment(property) &&
+    !isShorthandPropertyAssignment(property) &&
+    !isMethodDeclaration(property) &&
+    !isGetAccessorDeclaration(property) &&
+    !isSetAccessorDeclaration(property)
+  ) {
+    return undefined;
+  }
+  const name = property.name;
+  if (isIdentifier(name) || isStringLiteral(name) || isNumericLiteral(name)) {
+    return { node: name, text: name.text };
+  }
+  if (isComputedPropertyName(name)) {
+    const key = name.expression;
+    if (isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key)) {
+      return { node: name, text: key.text };
+    }
+  }
+  return undefined;
+}
+
+/** The parameter and result types of one call signature, each where the checker answered. */
+interface Called {
+  readonly parameters: readonly (Type | undefined)[];
+  readonly result: Type | undefined;
+}
+
+/** One object type a value is checked as, and the position's object types it is checked against. */
+interface Checked {
+  readonly source: Type;
+  readonly targets: readonly Type[];
+}
+
+/** How many element and signature steps the structural walk takes below a value's own type. */
+const MAX_DEPTH = 3;
+
+/** One member of an object type, by the inventory's declarations and the checker's declaration handles. */
+interface Member {
+  readonly ids: readonly string[];
+  readonly handles: ReadonlySet<string>;
+}
+
+/**
+ * The contextual uses of one project's literals and values, asked in batches: one
+ * contextual type per literal and per value whose type carries a member of the target,
+ * one type per value, and each distinct type's properties once.
+ */
+export function contextualUses<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  chains: AliasChains,
+  literals: readonly LiteralAt[],
+  flows: readonly FlowAt[],
+  cap: number,
+  properties: PropertyTables,
+): ContextualUses {
+  const queries = project.queries;
+  const kinds = new Map(held.symbols.map((symbol) => [symbol.id, symbol.kind]));
+  let batches = 0;
+  let lookups = 0;
+  const batchesOf = (count: number): number => Math.ceil(count / cap);
+
+  const parts = new Map<number, readonly Type[]>();
+  /** The object types one type is: itself, or its constituents at any depth. */
+  const partsOf = (type: Type): readonly Type[] => {
+    const known = parts.get(type.id);
+    if (known !== undefined) {
+      return known;
+    }
+    let found: readonly Type[] = [];
+    if (type.isUnionType() || type.isIntersectionType()) {
+      lookups += 1;
+      const constituents = queries.constituents(type);
+      found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+    } else if (type.isObjectType()) {
+      found = [type];
+    }
+    parts.set(type.id, found);
+    return found;
+  };
+
+  const tables = new Map<number, ReadonlyMap<string, Member>>();
+  /** The members one object type has, by name. */
+  const membersOf = (type: Type): ReadonlyMap<string, Member> => {
+    const known = tables.get(type.id);
+    if (known !== undefined) {
+      return known;
+    }
+    const table = new Map<string, Member>();
+    const read = properties.of(type);
+    lookups += read.asked ? 1 : 0;
+    for (const property of isAnswered(read.properties) ? read.properties : []) {
+      table.set(property.name, {
+        ids: chains
+          .declarationsOf(property)
+          .filter((id) => MEMBER_KINDS.has(kinds.get(id) ?? "file")),
+        handles: new Set(
+          property.declarations.map((handle) => `${handle.path}#${String(handle.index)}`),
+        ),
+      });
+    }
+    tables.set(type.id, table);
+    return table;
+  };
+
+  const writes: ContextualUse[] = [];
+  batches += batchesOf(literals.length);
+  const contexts = queries.contextualTypes(
+    literals.map((one) => one.literal),
+    cap,
+  );
+  literals.forEach(({ literal, from }, index) => {
+    const context = contexts[index];
+    if (context === undefined || !isAnswered(context)) {
+      return;
+    }
+    const tablesOf = partsOf(context).map(membersOf);
+    for (const property of literal.properties) {
+      const name = propertyName(property);
+      if (name === undefined) {
+        continue;
+      }
+      const ids = [...new Set(tablesOf.flatMap((table) => table.get(name.text)?.ids ?? []))];
+      if (ids.length > 0) {
+        writes.push({ at: name.node, from, ids });
+      }
+    }
+  });
+
+  const carried = flows.filter((flow) => !isObjectLiteralExpression(flow.value));
+  batches += batchesOf(carried.length);
+  const types = queries.typesAt(
+    carried.map((flow) => flow.value),
+    cap,
+  );
+  /** The members a position may read structurally: those of object types, not of classes. */
+  const readable = (member: Member): readonly string[] =>
+    member.ids.filter((id) => kinds.get(id) === "type-member");
+  const carries = (part: Type): boolean =>
+    [...membersOf(part).values()].some((member) => readable(member).length > 0);
+
+  const elements = new Map<number, Type | undefined>();
+  /** The element type of an array type, read once per type. */
+  const elementOf = (type: Type): Type | undefined => {
+    if (elements.has(type.id)) {
+      return elements.get(type.id);
+    }
+    lookups += 1;
+    const isArray = queries.isArray(type);
+    let element: Type | undefined;
+    if (isAnswered(isArray) && isArray) {
+      lookups += 1;
+      const held = queries.typeArguments(type);
+      element = isAnswered(held) ? held[0] : undefined;
+    }
+    elements.set(type.id, element);
+    return element;
+  };
+
+  const calls = new Map<number, Called | undefined>();
+  /** The parameter and return types of a type's one call signature, read once per type. */
+  const callOf = (type: Type): Called | undefined => {
+    if (calls.has(type.id)) {
+      return calls.get(type.id);
+    }
+    lookups += 1;
+    const signatures = queries.signaturesOf(type, SignatureKind.Call);
+    let called: Called | undefined;
+    const [signature, ...more] = isAnswered(signatures) ? signatures : [];
+    if (signature !== undefined && more.length === 0) {
+      const parameters = signature.parameters.map((_parameter, index) =>
+        queries.parameterType(signature, index),
+      );
+      const result = queries.returnTypeOf(signature);
+      lookups += parameters.length + 1;
+      called = {
+        parameters: parameters.map((one) => (isAnswered(one) ? one : undefined)),
+        result: isAnswered(result) ? result : undefined,
+      };
+    }
+    calls.set(type.id, called);
+    return called;
+  };
+
+  /**
+   * Each object type a value of `source` is checked as against the object types of
+   * `target`: the value's own, and through array elements and through a function's
+   * parameters, checked the other way, and its result. A source that is one of the
+   * target's own object types matches it as it stands.
+   */
+  const compared = (
+    source: Type | undefined,
+    target: Type | undefined,
+    depth: number,
+    into: Checked[],
+    seen: Set<string>,
+  ): void => {
+    const key = `${String(source?.id)}>${String(target?.id)}`;
+    if (source === undefined || target === undefined || source.id === target.id) {
+      return;
+    }
+    if (depth > MAX_DEPTH || seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    const targets = partsOf(target);
+    const sources = partsOf(source).filter((one) => !targets.some((part) => part.id === one.id));
+    for (const one of sources) {
+      if (carries(one)) {
+        into.push({ source: one, targets });
+      }
+      const element = elementOf(one);
+      const called = element === undefined ? callOf(one) : undefined;
+      for (const part of targets) {
+        if (element !== undefined) {
+          compared(element, elementOf(part), depth + 1, into, seen);
+          continue;
+        }
+        const other = called === undefined ? undefined : callOf(part);
+        if (called === undefined || other === undefined) {
+          continue;
+        }
+        other.parameters.forEach((parameter, index) => {
+          compared(parameter, called.parameters[index], depth + 1, into, seen);
+        });
+        compared(called.result, other.result, depth + 1, into, seen);
+      }
+    }
+  };
+
+  /** Whether a value of one type may carry a member a position reads, at any depth the walk takes. */
+  const mayCarry = (type: Type, depth: number): boolean =>
+    depth <= MAX_DEPTH &&
+    partsOf(type).some((part) => {
+      if (carries(part)) {
+        return true;
+      }
+      const element = elementOf(part);
+      if (element !== undefined) {
+        return mayCarry(element, depth + 1);
+      }
+      return callOf(part) !== undefined;
+    });
+
+  const sourced = carried.flatMap((flow, index) => {
+    const type = types[index];
+    return type === undefined || !isAnswered(type) || !mayCarry(type, 0) ? [] : [{ flow, type }];
+  });
+  batches += batchesOf(sourced.length);
+  const positions = queries.contextualTypes(
+    sourced.map((one) => one.flow.value),
+    cap,
+  );
+  const reads: ContextualUse[] = [];
+  sourced.forEach(({ flow, type }, index) => {
+    const position = positions[index];
+    if (position === undefined || !isAnswered(position)) {
+      return;
+    }
+    const checked: Checked[] = [];
+    compared(type, position, 0, checked, new Set());
+    const ids = new Set<string>();
+    for (const { source, targets } of checked) {
+      const tables = targets.map(membersOf);
+      for (const [name, member] of membersOf(source)) {
+        const read = tables.some((table) => {
+          const declared = table.get(name);
+          return (
+            declared !== undefined &&
+            declared.handles.size > 0 &&
+            ![...declared.handles].some((handle) => member.handles.has(handle))
+          );
+        });
+        if (read) {
+          for (const id of readable(member)) {
+            ids.add(id);
+          }
+        }
+      }
+    }
+    if (ids.size > 0) {
+      reads.push({ at: flow.value, from: flow.from, ids: [...ids] });
+    }
+  });
+  return { writes, reads, batches, lookups };
+}

package/src/convention-rows.ts

@@ -52,6 +52,8 @@ export interface ConventionRow {
   readonly entries: readonly string[];
   /** The globs of the files the row does not root, though an entry glob names them. */
   readonly excludes?: readonly string[];
+  /** The directories the framework generates, each of whose files is a generated file. */
+  readonly generated?: readonly string[];
   /** The directories configuration moves, in the order their placeholders depend on each other. */
   readonly moves: readonly DirectoryMove[];
 }
@@ -102,6 +104,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       `<src>/content/config.${MODULE}`,
     ],
     excludes: ["<src>/pages/**/_*", "<src>/pages/**/_*/**"],
+    generated: [".astro"],
     moves: [
       {
         id: "src",
@@ -128,6 +131,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     name: "next",
     package: "next",
     range: ">=13.4.0 <17.0.0",
+    generated: [".next"],
     entries: [
       `{,src/}app/**/{layout,page,loading,not-found,error,route,template,default,forbidden,unauthorized}.${SCRIPT}`,
       `{,src/}app/global-{error,not-found}.${SCRIPT}`,
@@ -144,6 +148,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     name: "nuxt",
     package: "nuxt",
     range: ">=3.0.0 <5.0.0",
+    generated: [".nuxt"],
     entries: [
       "<srcDir>/{app,error}.{vue,jsx,tsx}",
       `<srcDir>/app.config.${MODULE}`,
@@ -238,6 +243,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     package: "@react-router/dev",
     range: ">=7.0.0 <9.0.0",
     entries: APP_DIRECTORY_ENTRIES,
+    generated: [".react-router"],
     moves: [
       {
         id: "app",
@@ -316,6 +322,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     package: "@sveltejs/kit",
     range: ">=2.0.0 <3.0.0",
     entries: [...SVELTEKIT_ENTRIES, "<params>/*.{js,ts}"],
+    generated: [".svelte-kit"],
     moves: [
       {
         id: "src",
@@ -380,6 +387,7 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     package: "@sveltejs/kit",
     range: ">=3.0.0 <4.0.0",
     entries: [...SVELTEKIT_ENTRIES, "<params>.{js,ts}"],
+    generated: [".svelte-kit"],
     moves: [
       {
         id: "src",

package/src/conventions.ts

@@ -22,6 +22,8 @@ import {
   isNamespaceImport,
   isNoSubstitutionTemplateLiteral,
   isNonNullExpression,
+  isNumericLiteral,
+  isObjectBindingPattern,
   isObjectLiteralExpression,
   isParenthesizedExpression,
   isPropertyAccessExpression,
@@ -33,7 +35,9 @@ import {
   isVariableStatement,
   SyntaxKind,
   type AsExpression,
+  type Identifier,
   type Node,
+  type ObjectBindingPattern,
   type NonNullExpression,
   type ObjectLiteralExpression,
   type ParenthesizedExpression,
@@ -81,6 +85,14 @@ interface ConventionGlob {
   readonly excludes: readonly RegExp[];
 }
 
+/** One directory an applied row names as generated, read against its manifest's directory. */
+interface GeneratedDirectory {
+  readonly dir: string;
+  readonly row: string;
+  /** The directory below the manifest's directory, `/`-separated. */
+  readonly below: string;
+}
+
 /** A setup failure a row met, at the directory of the manifest that declared it. */
 interface ConventionFailure {
   readonly dir: string;
@@ -92,6 +104,7 @@ export interface Conventions {
   /** The rows applied, ordered by name, then manifest, then their compact encoding. */
   readonly applied: readonly AppliedConvention[];
   readonly globs: readonly ConventionGlob[];
+  readonly generated: readonly GeneratedDirectory[];
   readonly failures: readonly ConventionFailure[];
 }
 
@@ -105,9 +118,11 @@ interface ConventionEntry {
 /** Parses one file's text with no program. */
 type ParseSource = (fileName: string, text: string) => SourceFile;
 
+/** The sections an installed package is required by, so its absence fails the run. */
+const REQUIRED_SECTIONS = ["dependencies", "devDependencies"] as const;
+
 const DEPENDENCY_SECTIONS = [
-  "dependencies",
-  "devDependencies",
+  ...REQUIRED_SECTIONS,
   "peerDependencies",
   "optionalDependencies",
 ] as const;
@@ -124,11 +139,15 @@ function readJSON(host: Host, path: string): unknown {
   }
 }
 
-function declares(manifest: unknown, name: string): boolean {
+function declares(
+  manifest: unknown,
+  name: string,
+  sections: readonly string[] = DEPENDENCY_SECTIONS,
+): boolean {
   if (!isRecord(manifest)) {
     return false;
   }
-  return DEPENDENCY_SECTIONS.some((section) => {
+  return sections.some((section) => {
     const held = manifest[section];
     return isRecord(held) && Object.hasOwn(held, name);
   });
@@ -174,21 +193,33 @@ function unwrapped(node: Node): Node {
   return at;
 }
 
-/** The key one property is written with, where it is written as a name or a literal. */
+/** 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;
-  if (isComputedPropertyName(name)) {
-    return undefined;
-  }
-  if (isIdentifier(name) || isStringLiteral(name) || isNoSubstitutionTemplateLiteral(name)) {
-    return name.text;
+  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 values one file's top-level variable declarations bind, by name. */
 function declaredValues(file: SourceFile): ReadonlyMap<string, Node> {
   const values = new Map<string, Node>();
@@ -247,6 +278,79 @@ function defaultExports(file: SourceFile): readonly Node[] {
   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.
@@ -254,6 +358,26 @@ function defaultExports(file: SourceFile): readonly Node[] {
 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
@@ -333,7 +457,7 @@ function readPath(
 ): Node | undefined {
   const [key, ...rest] = keys;
   for (const member of object.properties) {
-    if (isSpreadAssignment(member)) {
+    if (isSpreadAssignment(member) || computesKey(member)) {
       return member;
     }
     if (keyOf(member) !== key) {
@@ -518,6 +642,7 @@ export function readConventions(
 ): Conventions {
   const applied: AppliedConvention[] = [];
   const globs: ConventionGlob[] = [];
+  const generated: GeneratedDirectory[] = [];
   const failures: ConventionFailure[] = [];
   for (const manifest of manifests) {
     const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
@@ -532,7 +657,7 @@ export function readConventions(
       }
       const version = versions.get(row.package);
       if (version === undefined) {
-        if (missing.has(row.package)) {
+        if (missing.has(row.package) || !declares(declared, row.package, REQUIRED_SECTIONS)) {
           continue;
         }
         missing.add(row.package);
@@ -580,6 +705,9 @@ export function readConventions(
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
       ].map(globExpression);
+      for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
+        generated.push({ dir: manifest.dir, row: row.name, below });
+      }
       for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
         globs.push({
           dir: manifest.dir,
@@ -597,7 +725,27 @@ export function readConventions(
       compare(a.manifest, b.manifest) ||
       compare(JSON.stringify(a), JSON.stringify(b)),
   );
-  return { applied: unique, globs, failures };
+  return { applied: unique, globs, generated, failures };
+}
+
+/**
+ * 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.
+ */
+export function generatedFiles(
+  conventions: Conventions,
+  files: SourceFiles,
+): ReadonlyMap<string, string> {
+  const found = new Map<string, string>();
+  for (const { dir, row, below } of conventions.generated) {
+    const root = joinPath(dir, below);
+    for (const [path, file] of files.byPath) {
+      if (!found.has(path) && relativePath(root, file.fileName) !== undefined) {
+        found.set(path, row);
+      }
+    }
+  }
+  return found;
 }
 
 /** Every own file of one project an applied row's globs match, once per row. */