@cplieger/deadset-ts 6.0.0 → 6.1.0

package/dist/src/overrides.js

@@ -1,15 +1,17 @@
 /**
  * The overrides of the target's class members. A call through the base class names the
  * base's member and runs the override of whichever subclass the value is, so the base
- * member's declaration references every override. A method overriding a member of a class
- * declared outside the target, at any depth of its `extends` chain, is called by outside
- * code holding the instance through that class, so its own class references it.
+ * member's declaration references every override. A method, an accessor or a property,
+ * static or not, overriding a member of a class declared outside the target, at any depth
+ * of its `extends` chain, is used by outside code holding the instance or the class
+ * through that class, so its own class references it.
  */
 import { isClassDeclaration, isClassExpression, isExpressionWithTypeArguments, isPropertyAccessExpression, isQualifiedName, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { memberComponent } from "./class-members.js";
 import { nodeKey } from "./inventory.js";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { UNANSWERED } from "./query.js";
+import { nameComponent } from "./ref.js";
 /** The member kinds a subclass overrides. */
 const OVERRIDABLE = new Set(["method", "class-member"]);
 /** The node naming the class one `extends` entry names. */
@@ -40,7 +42,7 @@ function extending(project, held) {
 }
 /**
  * The references each base class member makes to its overrides, for the classes of one
- * project that extend another class of the target, and each class makes to its methods
+ * project that extend another class of the target, and each class makes to its members
  * that override a member of a class declared outside the target. A member a nearer base
  * already overrides is reached through that override. A private member is not
  * overridden. Each reference is placed at the override and made by its file.
@@ -102,7 +104,7 @@ export function overrideReferences(project, held, chains, testFiles) {
     const outsideNames = outsideMemberNames(project, bases, outsideBases);
     for (const [classId, names] of outsideNames) {
         for (const [component, member] of members.get(classId) ?? []) {
-            if (member.kind === "method" && names.has(component)) {
+            if (names.has(component)) {
                 found.push({
                     from: classId,
                     to: member.id,
@@ -133,15 +135,20 @@ export function overrideReferences(project, held, chains, testFiles) {
 }
 /**
  * Per class of the target with a class declared outside the target in its `extends`
- * chain, the names of the members that outside class's instances carry.
+ * chain, the member components that outside class's instances and constructor carry, a
+ * static one spelled as a static member's component is.
  */
 function outsideMemberNames(project, bases, outsideBases) {
     const direct = new Map();
     for (const [classId, base] of outsideBases) {
-        const type = project.queries.declaredTypeOf(base);
-        const properties = type === UNANSWERED ? UNANSWERED : project.queries.propertiesOf(type);
-        if (properties !== UNANSWERED) {
-            direct.set(classId, new Set(properties.map((property) => property.escapedName)));
+        const instance = project.queries.declaredTypeOf(base);
+        const statics = project.queries.typeOfSymbol(base);
+        const components = [
+            ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+            ...namesOf(project, statics === UNANSWERED ? undefined : statics).map((name) => `${nameComponent(name)}:static`),
+        ];
+        if (components.length > 0) {
+            direct.set(classId, new Set(components));
         }
     }
     const names = new Map();
@@ -163,3 +170,8 @@ function outsideMemberNames(project, bases, outsideBases) {
     }
     return names;
 }
+/** The names of a type's properties; none where the type or its properties are unanswered. */
+function namesOf(project, type) {
+    const properties = type === undefined ? UNANSWERED : project.queries.propertiesOf(type);
+    return properties === UNANSWERED ? [] : properties.map((property) => property.name);
+}

package/dist/src/ref.js

@@ -43,7 +43,7 @@ const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/package\\.json`;
 export const REF_EXPRESSIONS = [
     `^${SCOPE}#$`,
     `^${SCOPE}#${TS_HEAD}$`,
-    `^${SCOPE}#${TS_HEAD}:alias$`,
+    `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
@@ -66,6 +66,9 @@ export function nameComponent(name) {
     if (IDENTIFIER.test(name) || PRIVATE_NAME.test(name)) {
         return name;
     }
+    return quoted(name);
+}
+function quoted(name) {
     const escaped = name
         .replaceAll("\\", "\\\\")
         .replaceAll("'", "\\'")
@@ -82,6 +85,11 @@ export function nameComponent(name) {
 export function computedComponent(text) {
     return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
+/** The fragment of an export alias, inside the `declare module` block named, if one is. */
+export function aliasFragment(name, block) {
+    const head = block === undefined ? "" : `${quoted(block)}.`;
+    return `${head}${nameComponent(name)}:alias`;
+}
 function spell(component) {
     return component.computed ? computedComponent(component.text) : nameComponent(component.text);
 }
@@ -96,7 +104,7 @@ export function renderRef(module, fragment) {
         case "module":
             return `${scope}#`;
         case "alias":
-            return `${scope}#${nameComponent(fragment.name)}:alias`;
+            return `${scope}#${aliasFragment(fragment.name, fragment.block)}`;
         case "dependency":
             return `${scope}#${fragment.name}:${fragment.section}`;
         case "declaration": {
@@ -107,6 +115,14 @@ export function renderRef(module, fragment) {
         }
     }
 }
+/**
+ * One declaration's key among a run's: its reference and the file that declares it. Two
+ * packages of one name spell one reference for two declarations, so the reference alone
+ * keys neither.
+ */
+export function declarationKey(ref, path) {
+    return `${ref}\u0000${path}`;
+}
 /**
  * Whether one string is a reference of this language's grammar, in its canonical
  * spelling. A string that is not, whether misspelled or spelled in a form the

package/dist/src/reporters/sarif.js

@@ -1,5 +1,6 @@
 import { jsonChunks } from "../json-chunks.js";
 import { KINDS } from "../kinds.js";
+import { declarationKey } from "../ref.js";
 import { lineHashes, symbolFingerprint } from "./fingerprint.js";
 import { RenderError } from "./reporter.js";
 import { utf8Bytes } from "./sha256.js";
@@ -122,7 +123,8 @@ function relatedOf(found) {
         related.push({ label: "write", at, endLine: at.end_line });
     }
     for (const one of found.component.members ?? []) {
-        if (one.ref !== found.symbol.ref) {
+        if (declarationKey(one.ref, one.position.path) !==
+            declarationKey(found.symbol.ref, found.position.path)) {
             related.push({ label: "member", at: one.position, endLine: one.position.end_line });
         }
     }

package/dist/src/suppress-file.js

@@ -7,6 +7,7 @@
 import { jsonChunks } from "./json-chunks.js";
 import { joinPath } from "./paths.js";
 import { positionAt, walkDocument } from "./json-document.js";
+import { declarationKey } from "./ref.js";
 import { CODE_FORM, SUPPRESSION_WITHOUT_REASON, SuppressionError, UNSCOPED_ENTRY, blankReason, isEntryPath, isSymbolRef, siteText, } from "./suppress.js";
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
@@ -38,9 +39,6 @@ function documentSite(shape) {
 function isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function referenceKey(ref, path) {
-    return `${ref}\u0000${path}`;
-}
 /**
  * Reads one entry or row: the records it binds, the refusals it carries, or the
  * malformed value that ends the run.
@@ -100,7 +98,7 @@ function readRecord(value, site, byReference, shape) {
     if (refusals.length > 0) {
         return { records: [], refusals };
     }
-    const named = byReference.get(referenceKey(symbol, written.path)) ?? [];
+    const named = byReference.get(declarationKey(symbol, written.path)) ?? [];
     if (named.length === 0) {
         return { records: [{ ...written, bound: "" }], refusals: [] };
     }
@@ -109,7 +107,7 @@ function readRecord(value, site, byReference, shape) {
 function byReferenceOf(symbols) {
     const byReference = new Map();
     for (const symbol of symbols) {
-        const key = referenceKey(symbol.ref, symbol.position.path);
+        const key = declarationKey(symbol.ref, symbol.position.path);
         byReference.set(key, [...(byReference.get(key) ?? []), symbol]);
     }
     return byReference;

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "6.0.0";
+export const CONTRACT_VERSION = "6.1.0";

package/dist/src/workspace-programs.js

@@ -7,7 +7,7 @@
  */
 import { ModuleKind, ModuleResolutionKind } from "@typescript/native/unstable/sync";
 import { isStringLiteralLikeNode } from "@typescript/native/unstable/ast";
-import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+import { dirnamePath, resolvePath } from "./paths.js";
 /** The most questions one round trip carries. */
 const BATCH = 2048;
 /**
@@ -20,31 +20,6 @@ function analysisOptions(parsed) {
     const { composite, rootDir: _rootDir, outDir: _outDir, declarationDir: _declarationDir, tsBuildInfoFile: _tsBuildInfoFile, ...kept } = parsed.options;
     return composite === true ? { ...kept, declaration: true } : kept;
 }
-/**
- * The references a built program can carry: only where every referenced
- * configuration reads and is composite with output, because the compiler reports a
- * broken reference at syntax a built program does not have.
- */
-function carriedReferences(engine, parsed) {
-    const references = parsed.projectReferences ?? [];
-    for (const reference of references) {
-        // A reference that names a directory names the `tsconfig.json` in it.
-        const configFile = reference.path.endsWith(".json")
-            ? reference.path
-            : joinPath(reference.path, "tsconfig.json");
-        let options;
-        try {
-            options = engine.parseConfigFile(configFile).options;
-        }
-        catch {
-            return [];
-        }
-        if (options.composite !== true || options.noEmit === true) {
-            return [];
-        }
-    }
-    return references;
-}
 /** The conditions an `exports` lookup under one configuration and one resolution mode reads. */
 function conditionsOf(parsed, mode) {
     const resolution = parsed.options.moduleResolution;
@@ -94,7 +69,7 @@ function configurationOf(engine, host, reading) {
     if (reason !== undefined) {
         return { kind: "unread", reason };
     }
-    const { options } = reading.parsed;
+    const { options, projectReferences: references = [] } = reading.parsed;
     const raw = options["pathsBasePath"];
     const base = typeof raw === "string" ? raw : dirnamePath(reading.configFile);
     const paths = {};
@@ -117,8 +92,8 @@ function configurationOf(engine, host, reading) {
             ...(options.composite === true ? { composite: false, declaration: true } : {}),
             paths,
         },
-        ...(reading.references.length > 0
-            ? { references: reading.references.map((reference) => ({ path: reference.path })) }
+        ...(references.length > 0
+            ? { references: references.map((reference) => ({ path: reference.path })) }
             : {}),
         ...(exclude === undefined ? {} : { exclude }),
     });
@@ -150,6 +125,7 @@ function configurationOf(engine, host, reading) {
 /** The program one configuration is built as, under the answers it holds so far. */
 function programOf(engine, reading) {
     const compilerOptions = analysisOptions(reading.parsed);
+    const references = reading.parsed.projectReferences ?? [];
     const resolver = engine.createModuleResolver(compilerOptions, reading.entries);
     return {
         resolver,
@@ -159,7 +135,7 @@ function programOf(engine, reading) {
             options: {
                 moduleResolver: resolver,
                 configFileParsingDiagnostics: reading.parsed.errors,
-                ...(reading.references.length > 0 ? { projectReferences: reading.references } : {}),
+                ...(references.length > 0 ? { projectReferences: references } : {}),
             },
         },
     };
@@ -292,7 +268,6 @@ export function workspacePrograms(engine, host, configFiles, resolver) {
             {
                 configFile,
                 parsed,
-                references: carriedReferences(engine, parsed),
                 entries: [],
                 seen: new Set(),
                 bound: new Map(),

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "6.0.0",
+  "version": "6.1.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -29,7 +29,7 @@
     "lint:fix": "eslint . --fix && prettier --write ."
   },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.1.0-dev.20261006.1"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261007.1"
   },
   "overrides": {
     "qs": "^6.15.2"

package/src/configured-declarations.ts

@@ -207,8 +207,8 @@ function modulesNamed<Brand>(
 }
 
 /**
- * The declaration each entry names in one project. A symbol entry names the
- * inventory's declaration whose reference it spells exactly; a module entry names the
+ * The declaration each entry names in one project. A symbol entry names every
+ * declaration of the inventory whose reference it spells exactly; a module entry names the
  * declaration its path reaches from the exports of the module its specifier resolves
  * to; a global entry names the declaration its path reaches from the global scope.
  * Every alias along a path is followed to the declaration it stands for.
@@ -221,15 +221,17 @@ export function resolveEntries<Brand>(
   if (entries.length === 0) {
     return [];
   }
-  const byRef = new Map(held.symbols.map((symbol) => [symbol.ref, symbol.id]));
+  const byRef = new Map<string, string[]>();
+  for (const symbol of held.symbols) {
+    byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
+  }
   const modules = modulesNamed(
     project,
     new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))),
   );
   return entries.map((entry) => {
     if (entry.shape === "symbol") {
-      const id = byRef.get(entry.symbol);
-      return { entry, handles: new Set<string>(), ids: new Set(id === undefined ? [] : [id]) };
+      return { entry, handles: new Set<string>(), ids: new Set(byRef.get(entry.symbol) ?? []) };
     }
     const { components, static: isStatic } = componentsOf(
       entry.shape === "module" ? entry.name : entry.global,

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "4.0.0",
+    corpusVersion: "4.1.0",
     result: "pass",
-    digest: "sha256:8250b61deb71467139bf4cbcaf10802cdabb1a2c2261a11a571fc1ff55bfc3dc",
+    digest: "sha256:167f770cdff2776fa7ab28b7ff6121c4d7bdb01d83c5ba0057d9303281614008",
   },
   gaps: [],
 } as const;

package/src/convention-rows.ts

@@ -31,6 +31,20 @@ export interface ShortNameReading extends MoveReading {
   readonly package: string;
 }
 
+/**
+ * One configuration property whose value makes the tool's output import a runtime helper
+ * package, so the package is used where the property holds that value.
+ */
+export interface HelperReading extends MoveReading {
+  /**
+   * The value: `true`, or a string the property holds, alone, as an element of an array,
+   * or as the first element of an array that is such an element.
+   */
+  readonly value: true | string;
+  /** The package the output imports its helpers from. */
+  readonly package: string;
+}
+
 /** One directory a row's globs name that a configuration property moves. */
 export interface DirectoryMove {
   /** The placeholder the row's globs and later moves write as `<id>`. */
@@ -71,6 +85,8 @@ export interface ConventionRow {
   readonly selections?: readonly MoveReading[];
   /** The members of a `package.json` the tool reads its configuration from. */
   readonly manifestKeys?: readonly string[];
+  /** The settings that make the tool's output import a runtime helper package. */
+  readonly helpers?: readonly HelperReading[];
 }
 
 const SCRIPT = "{js,jsx,ts,tsx}";
@@ -105,6 +121,12 @@ const SOLIDSTART_PLUGIN = { module: "@solidjs/start/config", export: "solidStart
 
 const NUXT_CONFIG = [`nuxt.config.${ANY_MODULE}`];
 
+const BABEL_CONFIG = [
+  "babel.config.{json,js,cjs,mjs,cts,mts,ts}",
+  ".babelrc",
+  ".babelrc.{json,js,cjs,mjs,cts}",
+];
+
 const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
@@ -132,6 +154,19 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "babel",
+    package: "@babel/core",
+    range: ">=7.0.0 <9.0.0",
+    entries: [],
+    moves: [],
+    helpers: ["@babel/plugin-transform-runtime", "@babel/transform-runtime"].map((value) => ({
+      property: "plugins",
+      files: BABEL_CONFIG,
+      value,
+      package: "@babel/runtime",
+    })),
+  },
   {
     name: "eslint",
     package: "eslint",
@@ -304,6 +339,21 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "rolldown",
+    package: "rolldown",
+    range: ">=1.0.0 <2.0.0",
+    entries: [],
+    moves: [],
+    helpers: [
+      {
+        property: "transform.helpers.mode",
+        files: [`rolldown.config.${ANY_MODULE}`],
+        value: "Runtime",
+        package: "@oxc-project/runtime",
+      },
+    ],
+  },
   {
     name: "solidstart",
     package: "@solidjs/start",
@@ -350,7 +400,10 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     range: ">=7.0.0 <11.0.0",
     entries: [STRYKER_MODULE],
     moves: [],
-    selections: [{ property: "mutate", files: [STRYKER_CONFIG] }],
+    selections: [
+      { property: "mutate", files: [STRYKER_CONFIG] },
+      { property: "ignorePatterns", files: [STRYKER_CONFIG] },
+    ],
     shortNames: [
       {
         property: "testRunner",
@@ -481,6 +534,36 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "swc",
+    package: "@swc/core",
+    range: ">=1.0.0 <2.0.0",
+    entries: [],
+    moves: [],
+    helpers: [
+      {
+        property: "jsc.externalHelpers",
+        files: [".swcrc"],
+        value: true,
+        package: "@swc/helpers",
+      },
+    ],
+  },
+  {
+    name: "vite",
+    package: "vite",
+    range: ">=8.0.0 <9.0.0",
+    entries: [],
+    moves: [],
+    helpers: [
+      {
+        property: "oxc.helpers.mode",
+        files: [VITE_CONFIG],
+        value: "Runtime",
+        package: "@oxc-project/runtime",
+      },
+    ],
+  },
   {
     name: "vitest",
     package: "vitest",

package/src/conventions.ts

@@ -50,6 +50,7 @@ import {
   CONVENTION_ROWS,
   type ConventionRow,
   type DirectoryMove,
+  type HelperReading,
   type MoveReading,
   type OptionsCall,
   type ShortNameReading,
@@ -110,7 +111,10 @@ export interface Conventions {
   readonly globs: readonly ConventionGlob[];
   readonly generated: readonly GeneratedDirectory[];
   readonly failures: readonly ConventionFailure[];
-  /** The dependencies the applied rows' short names and manifest keys use, by name, each once. */
+  /**
+   * The dependencies the applied rows' short names, manifest keys and helper settings use,
+   * by name, each once.
+   */
   readonly uses: readonly string[];
   /** Per configuration file, absolute, the strings its applied rows' selection keys hold. */
   readonly selected: ReadonlyMap<string, Selected>;
@@ -136,6 +140,9 @@ type ParseSource = (fileName: string, text: string) => SourceFile;
 
 const JSON_EXTENSION = ".json";
 
+/** A configuration file with no extension that its tool reads as a JSON document. */
+const JSON_RC = /^\.[\w-]+rc$/u;
+
 /** The sections an installed package is required by, so its absence fails the run. */
 const REQUIRED_SECTIONS = ["dependencies", "devDependencies"] as const;
 
@@ -533,11 +540,10 @@ function readPath(
 }
 
 /**
- * Every string literal one file writes at one property's path inside the objects it is
- * read from, as {@link readProperty} reads them: the value itself, or each element of an
- * array value, whatever else the path holds.
+ * 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 stringsAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
+function valuesAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
   const declared = declaredValues(file);
   const objects =
     call === undefined
@@ -558,10 +564,8 @@ function stringsAt(file: SourceFile, property: string, call?: OptionsCall): read
       const held = unwrapped(member.initializer);
       if (rest.length > 0) {
         visit(held, rest);
-      } else if (literalText(held) !== undefined) {
+      } else {
         found.push(held);
-      } else if (isArrayLiteralExpression(held)) {
-        found.push(...held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined));
       }
     }
   };
@@ -573,6 +577,36 @@ function stringsAt(file: SourceFile, property: string, call?: OptionsCall): read
   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)
+      : [];
+  });
+}
+
+/** Whether one value holds a helper setting's value, as {@link HelperReading} states it. */
+function holdsValue(held: Node, value: true | string): boolean {
+  if (value === true) {
+    return held.kind === SyntaxKind.TrueKeyword;
+  }
+  if (literalText(held) === value) {
+    return true;
+  }
+  return (
+    isArrayLiteralExpression(held) &&
+    held.elements.some((element) => {
+      const one = unwrapped(element);
+      const first = isArrayLiteralExpression(one) ? one.elements[0] : one;
+      return first !== undefined && literalText(first) === value;
+    })
+  );
+}
+
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(
   host: Host,
@@ -760,7 +794,11 @@ function readingFiles(
       } catch {
         continue;
       }
-      found.push({ name, text, file: parse(path, text) });
+      found.push({
+        name,
+        text,
+        file: parse(JSON_RC.test(name) ? `${path}${JSON_EXTENSION}` : path, text),
+      });
     }
   }
   return found;
@@ -808,6 +846,33 @@ function shortNameUses(
   return [...used].filter((name) => declared.has(name)).sort(compare);
 }
 
+/** The declared dependencies an applied row's helper settings use. */
+function helperUses(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  manifest: unknown,
+  readings: readonly HelperReading[],
+): readonly string[] {
+  const declared = new Set(
+    DEPENDENCY_SECTIONS.flatMap((section) => {
+      const held = isRecord(manifest) ? manifest[section] : undefined;
+      return isRecord(held) ? Object.keys(held) : [];
+    }),
+  );
+  return readings
+    .filter(
+      (reading) =>
+        declared.has(reading.package) &&
+        readingFiles(host, parse, dir, reading.files).some(({ file }) =>
+          valuesAt(file, reading.property, reading.call).some((held) =>
+            holdsValue(held, reading.value),
+          ),
+        ),
+    )
+    .map((reading) => reading.package);
+}
+
 /** Two strings ordered bytewise. */
 function compare(a: string, b: string): number {
   if (a === b) {
@@ -897,6 +962,9 @@ export function readConventions(
       for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
         uses.add(name);
       }
+      for (const name of helperUses(host, parse, manifest.dir, declared, row.helpers ?? [])) {
+        uses.add(name);
+      }
       selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),