@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/src/references.ts

@@ -51,6 +51,7 @@ import { byPosition, isComponentFile, renderPosition, type Position } from "./po
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
+import { computedKeyNames, keyNameOf, keyedUses, type KeyedAccess } from "./symbol-keys.ts";
 import { handedOn, valuesOf } from "./value-flow.ts";
 
 /**
@@ -77,17 +78,17 @@ import { handedOn, valuesOf } from "./value-flow.ts";
  * `decorator` names the declaration a decorator expression is attached to, which the
  * decorator receives when the class is defined.
  */
-export type Use = "read" | "write" | "evaluation" | "decorator";
+type Use = "read" | "write" | "evaluation" | "decorator";
 
 /**
- * Which path answered for one reference: `batch`, a file's batched lookup; `resolved-symbol`,
- * the per-node lookup for its residue; `shorthand`, the value `{ a }` reads; `alias`, a step
- * along an import or export chain; `syntax`, the tree alone (a decorator's target, a
- * component's markup); `destructured`, the property a pattern names; `contextual`, the member
- * a literal property writes or a value's position reads; `override`, the override a base
- * member's call dispatches to; `by-name`, every declaration so spelled, where the checker failed.
+ * Which path answered for one reference: `batch`, a file's batched lookup; `resolved-symbol`, the
+ * per-node lookup for its residue; `shorthand`, the value `{ a }` reads; `alias`, a step along an
+ * import or export chain; `syntax`, the tree alone (a decorator's target, a component's markup);
+ * `destructured`, the property a pattern names; `contextual`, the member a literal property writes
+ * or a value's position reads; `override`, the override a base call dispatches to; `keyed`, the
+ * member a symbol key selects; `by-name`, each declaration so spelled, where the checker failed.
  */
-export type Resolution =
+type Resolution =
   | "batch"
   | "resolved-symbol"
   | "shorthand"
@@ -96,6 +97,7 @@ export type Resolution =
   | "destructured"
   | "contextual"
   | "override"
+  | "keyed"
   | "by-name";
 
 /** One use of one declaration by one declaration. */
@@ -187,8 +189,6 @@ export interface ReferenceCost {
 
 /** One project's references, in position order, and what reading them cost. */
 export interface References {
-  /** The compiler configuration the project was opened from. */
-  readonly configFile: string;
   readonly references: readonly Reference[];
   /**
    * Every file the rules classified as a test file, by its path below the target root,
@@ -212,6 +212,8 @@ export interface ReferenceOptions {
    * Each pattern is a rule of its own, which {@link testFileRulesOf} counts.
    */
   readonly testFiles: readonly string[];
+  /** The files, absolute, that are test files beside those the patterns name. */
+  readonly testFileNames?: ReadonlySet<string>;
   /**
    * The consumer whose files the pass walks instead of the target's. Its files are the
    * program's own files below its root and not below the target root, each position is
@@ -297,12 +299,11 @@ function unparenthesized(node: Node): Node {
  * Records the name one store writes into.
  *
  * A property access writes the member it names. An element access writes the collection
- * it stores into, because a collection a module only ever stores into holds nothing
- * anything reads, and the key is no declaration of the target. A destructuring target
- * writes each name it binds, through the spreads and the nested patterns it binds them
- * in.
+ * it stores into, since a collection a module only stores into holds nothing anything
+ * reads, and joins `accesses` for the member a unique-symbol key selects. A destructuring
+ * target writes each name it binds, through its spreads and nested patterns.
  */
-function markWrite(target: Node, writes: Set<number>): void {
+function markWrite(target: Node, writes: Set<number>, accesses: Set<Node>): void {
   const held = unparenthesized(target);
   if (isName(held)) {
     writes.add(held.pos);
@@ -315,37 +316,38 @@ function markWrite(target: Node, writes: Set<number>): void {
     return;
   }
   if (isElementAccessExpression(held)) {
+    accesses.add(held);
     // A store through a member's value lands in storage every holder of the value
     // reads, so it reads the member; a variable only ever stored into stays written.
     if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
-      markWrite(held.expression, writes);
+      markWrite(held.expression, writes, accesses);
     }
     return;
   }
   if (isArrayLiteralExpression(held)) {
     for (const element of held.elements) {
-      markWrite(element, writes);
+      markWrite(element, writes, accesses);
     }
     return;
   }
   if (isObjectLiteralExpression(held)) {
     for (const property of held.properties) {
       if (isPropertyAssignment(property)) {
-        markWrite(property.initializer, writes);
+        markWrite(property.initializer, writes, accesses);
         continue;
       }
       if (isShorthandPropertyAssignment(property)) {
-        markWrite(property.name, writes);
+        markWrite(property.name, writes, accesses);
         continue;
       }
       if (isSpreadAssignment(property)) {
-        markWrite(property.expression, writes);
+        markWrite(property.expression, writes, accesses);
       }
     }
     return;
   }
   if (isSpreadElement(held)) {
-    markWrite(held.expression, writes);
+    markWrite(held.expression, writes, accesses);
   }
 }
 
@@ -356,16 +358,21 @@ function markWrite(target: Node, writes: Set<number>): void {
  * holds. A store that reads its target as well records it in `reads`: a logical
  * assignment, and a compound assignment, an increment or a decrement whose value is used.
  */
-function markStores(node: Node, writes: Set<number>, reads: Set<number>): void {
+function markStores(
+  node: Node,
+  writes: Set<number>,
+  reads: Set<number>,
+  accesses: { readonly written: Set<Node>; readonly read: Set<Node> },
+): void {
   if (isBinaryExpression(node)) {
     const operator = node.operatorToken.kind;
     if (ASSIGNMENTS.has(operator)) {
-      markWrite(node.left, writes);
+      markWrite(node.left, writes, accesses.written);
       if (
         LOGICAL_ASSIGNMENTS.has(operator) ||
         (operator !== SyntaxKind.EqualsToken && !valueDiscarded(node))
       ) {
-        markWrite(node.left, reads);
+        markWrite(node.left, reads, accesses.read);
       }
     }
     return;
@@ -375,20 +382,20 @@ function markStores(node: Node, writes: Set<number>, reads: Set<number>): void {
       node.operator === SyntaxKind.PlusPlusToken ||
       node.operator === SyntaxKind.MinusMinusToken
     ) {
-      markWrite(node.operand, writes);
+      markWrite(node.operand, writes, accesses.written);
       if (!valueDiscarded(node)) {
-        markWrite(node.operand, reads);
+        markWrite(node.operand, reads, accesses.read);
       }
     }
     return;
   }
   if (isDeleteExpression(node)) {
-    markWrite(node.expression, writes);
+    markWrite(node.expression, writes, accesses.written);
     return;
   }
   if (isForInStatement(node) || isForOfStatement(node)) {
     if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) {
-      markWrite(node.initializer, writes);
+      markWrite(node.initializer, writes, accesses.written);
     }
   }
 }
@@ -475,6 +482,7 @@ interface FileSites {
   readonly wholes: readonly WholeRead[];
   readonly urls: readonly ModuleURL[];
   readonly decorated: readonly Decorated[];
+  readonly keyed: readonly KeyedAccess[];
 }
 
 /** Whether one node is `import.meta.url`. */
@@ -667,6 +675,8 @@ function sitesOf(
   const flows: FlowAt[] = [];
   const writes = new Set<number>();
   const alsoRead = new Set<number>();
+  const accesses = { written: new Set<Node>(), read: new Set<Node>() };
+  const keyed: KeyedAccess[] = [];
   const declared = new Set<number>();
   const shorthands = new Map<number, Node>();
   let enclosing = fileId;
@@ -712,7 +722,17 @@ function sitesOf(
       return;
     }
     markNames(node);
-    markStores(node, writes, alsoRead);
+    markStores(node, writes, alsoRead, accesses);
+    const key = isElementAccessExpression(node) ? keyNameOf(node.argumentExpression) : undefined;
+    if (key !== undefined && isElementAccessExpression(node)) {
+      const written = accesses.written.has(node);
+      keyed.push({
+        access: node,
+        key,
+        from: enclosing,
+        use: written ? (accesses.read.has(node) ? "both" : "write") : "read",
+      });
+    }
     if (isObjectLiteralExpression(node) && !isAssignmentPattern(node)) {
       literals.push({ literal: node, from: enclosing });
     }
@@ -747,7 +767,18 @@ function sitesOf(
   };
 
   file.forEachChild(visit);
-  return { uses: found, literals, flows, reads, links, evaluations, wholes, urls, decorated };
+  return {
+    uses: found,
+    literals,
+    flows,
+    reads,
+    links,
+    evaluations,
+    wholes,
+    urls,
+    decorated,
+    keyed,
+  };
 }
 
 /** The declaration kinds of a property an object literal declares. */
@@ -1194,7 +1225,9 @@ export function references<Brand>(
   const testFile = new Map<SourceFile, boolean>();
   for (const { file } of walked) {
     const path = renderPosition(file, root, 0).path;
-    const test = patterns.some((pattern) => pattern.test(path));
+    const test =
+      patterns.some((pattern) => pattern.test(path)) ||
+      options.testFileNames?.has(file.fileName) === true;
     testFile.set(file, test);
     if (test) {
       tests.push(path);
@@ -1230,7 +1263,19 @@ export function references<Brand>(
     }
   }
 
-  for (const { file, fileId, uses, reads, links, evaluations, wholes, urls, decorated } of walked) {
+  const keyNames = computedKeyNames(held.symbols);
+  for (const {
+    file,
+    fileId,
+    uses,
+    reads,
+    links,
+    evaluations,
+    wholes,
+    urls,
+    decorated,
+    keyed,
+  } of walked) {
     const test = testFile.get(file) === true;
     // A component file's markup may use any binding its blocks declare at the top level.
     const markup = isComponentFile(file);
@@ -1449,6 +1494,22 @@ export function references<Brand>(
       }
     });
 
+    const resolvedKeys = keyed.flatMap((access) => {
+      const symbol =
+        isIdentifier(access.key) && keyNames.has(access.key.text)
+          ? answered.get(access.key)
+          : undefined;
+      return typeof symbol === "object" ? [{ access, symbol }] : [];
+    });
+    for (const { access, ids } of keyedUses(project, chains, resolvedKeys, tables, cap)) {
+      const position = renderPosition(file, root, access.access.argumentExpression.getStart());
+      for (const id of ids) {
+        for (const use of access.use === "both" ? (["read", "write"] as const) : [access.use]) {
+          found.push({ from: access.from, to: id, position, use, resolution: "keyed", test });
+        }
+      }
+    }
+
     for (const site of uses) {
       const direct: Resolution =
         site.shorthand !== undefined
@@ -1510,7 +1571,6 @@ export function references<Brand>(
   );
 
   return {
-    configFile: project.configFile,
     references:
       consumer === undefined
         ? found

package/src/report.ts

@@ -30,14 +30,14 @@ export const ANALYZER_NAME = "deadset-ts";
 /** The language this analyzer claims. */
 export const LANGUAGE = "ts";
 
-export interface WirePosition {
+interface WirePosition {
   readonly path: string;
   readonly line: number;
   readonly column: number;
   readonly end_line: number;
 }
 
-export interface WireDetails {
+interface WireDetails {
   readonly narrower_visibility?: string;
   readonly implementations?: readonly {
     readonly ref: string;
@@ -54,6 +54,7 @@ export interface WireDetails {
     readonly reason?: string;
   };
   readonly overlap?: readonly string[];
+  readonly removes_last_use_of?: readonly string[];
 }
 
 /** One finding as the finding schema spells it. */
@@ -93,7 +94,7 @@ export interface WireFinding {
   readonly details: WireDetails;
 }
 
-export interface WireEdgeEvaluation {
+interface WireEdgeEvaluation {
   readonly edge: string;
   readonly side: string;
   readonly symbol: string;
@@ -178,7 +179,7 @@ interface ReportConsumer {
 }
 
 /** One consumer the scope declared and the run did not load, with why. */
-export interface UnavailableConsumer {
+interface UnavailableConsumer {
   readonly id: string;
   readonly reason: string;
 }
@@ -297,6 +298,9 @@ function wireDetails(details: FindingDetails): WireDetails {
           },
         }),
     ...(details.overlap === undefined ? {} : { overlap: details.overlap }),
+    ...(details.removesLastUseOf === undefined
+      ? {}
+      : { removes_last_use_of: details.removesLastUseOf }),
   };
 }
 

package/src/roots.ts

@@ -15,6 +15,8 @@ import {
   isQualifiedName,
   isTypeQueryNode,
   isTypeReferenceNode,
+  isPropertyDeclaration,
+  isVariableDeclaration,
   isVariableStatement,
   type Node,
   type SourceFile,
@@ -31,6 +33,7 @@ import { relativePath, resolvePath } from "./paths.ts";
 import { byPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
+import type { Symbol as TSSymbol, Type } from "@typescript/native/unstable/sync";
 import { sourceFilesOf } from "./source-files.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
 
@@ -78,8 +81,6 @@ export interface Root {
 
 /** One project's roots, and every configured string that named nothing in it. */
 export interface Roots {
-  /** The compiler configuration the project was opened from. */
-  readonly configFile: string;
   /**
    * Every root of this project, ordered by the site of the declaration it names,
    * then by kind, then by the string that named it. A declaration that is a root for
@@ -128,6 +129,26 @@ export interface RootOptions {
   readonly parse?: ParseFile | undefined;
   /** Whether the target is a library, so a consumer outside it reaches its published API. */
   readonly publishedAPI: boolean;
+  /**
+   * The directories of the workspace members whose manifest is not private, each a library
+   * inside the target whose entries are published API whatever the target's kind.
+   */
+  readonly publishedMembers?: ReadonlySet<string> | undefined;
+}
+
+/** Whether one declaration is written below the directory of a published workspace member. */
+function inPublishedMember(
+  held: Inventory,
+  id: string,
+  root: string,
+  members: ReadonlySet<string> | undefined,
+): boolean {
+  const path = held.symbols.find((symbol) => symbol.id === id)?.position.path;
+  if (path === undefined || members === undefined) {
+    return false;
+  }
+  const file = resolvePath(root, path);
+  return [...members].some((dir) => file.startsWith(`${dir}/`));
 }
 
 /** The kind of root each role of a manifest entry makes. */
@@ -305,10 +326,16 @@ export function roots<Brand>(
     ...options.manifest.entries.map((entry) => ({
       entry,
       publishes:
+        options.publishedAPI &&
         entry.published &&
         (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
     })),
-    ...(options.otherPackages ?? []).map((entry) => ({ entry, publishes: entry.published })),
+    ...(options.otherPackages ?? []).map((entry) => ({
+      entry,
+      publishes:
+        entry.published &&
+        (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
+    })),
   ];
   const scripted = entries.flatMap(({ entry }) =>
     entry.role === "script" ? files.named(entry.path) : [],
@@ -324,7 +351,7 @@ export function roots<Brand>(
       : readBackByName(options.host, entry, readBackTo);
   };
   for (const { entry, publishes } of entries) {
-    if (options.publishedAPI && publishes) {
+    if (publishes) {
       published.push(...entryFiles(entry));
     }
   }
@@ -380,9 +407,14 @@ export function roots<Brand>(
     }
   }
 
-  const api = options.publishedAPI
-    ? publishedAPI(project, published, exportsOf, held, files.byPath, releaseTagged(held, files))
-    : { ids: [], guessed: [] };
+  const tagged = releaseTagged(held, files).filter(
+    (id) =>
+      options.publishedAPI || inPublishedMember(held, id, targetRoot, options.publishedMembers),
+  );
+  const api =
+    published.length > 0 || tagged.length > 0
+      ? publishedAPI(project, published, exportsOf, held, files.byPath, tagged)
+      : { ids: [], guessed: [] };
   for (const id of api.ids) {
     add(id, "published-api", "");
   }
@@ -398,7 +430,6 @@ export function roots<Brand>(
   });
 
   return {
-    configFile: project.configFile,
     liveUnderReachability: ordered,
     unmatched,
     unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
@@ -560,6 +591,18 @@ function publishedAPI<Brand>(
       const symbol = byId.get(id);
       return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
     });
+    for (const symbol of inferredTypeSymbols(
+      project,
+      round.flatMap((id) => {
+        const symbol = byId.get(id);
+        const node = symbol === undefined ? undefined : nodes.nodeOf(symbol);
+        return node === undefined ? [] : [node];
+      }),
+    )) {
+      for (const target of chains.chainOf(symbol)) {
+        reach(target.id);
+      }
+    }
     project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
       if (symbol === UNANSWERED) {
         for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
@@ -580,7 +623,10 @@ function publishedAPI<Brand>(
 function declarationNodes(
   held: Inventory,
   byPath: ReadonlyMap<string, SourceFile>,
-): { typeNamesOf(symbol: InventorySymbol): readonly Node[] } {
+): {
+  typeNamesOf(symbol: InventorySymbol): readonly Node[];
+  nodeOf(symbol: InventorySymbol): Node | undefined;
+} {
   const walked = new Map<string, { byId: Map<string, Node>; nodes: Set<Node> }>();
   const nodesIn = (path: string): { byId: Map<string, Node>; nodes: Set<Node> } => {
     const known = walked.get(path);
@@ -611,7 +657,81 @@ function declarationNodes(
       const declaration = byId.get(symbol.id);
       return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
     },
+    nodeOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id),
+  };
+}
+
+/** How deep the type arguments and constituents of an inferred type are followed. */
+const INFERRED_DEPTH = 4;
+
+/**
+ * The declarations of the types the compiler infers where a declaration writes none: the
+ * type of a variable or a property with no annotation, and the result of a function or a
+ * method with no result annotation, each with the types its type arguments and its union
+ * or intersection constituents name, to a fixed depth. A question the checker leaves
+ * unanswered names nothing.
+ */
+function inferredTypeSymbols<Brand>(
+  project: ProjectView<Brand>,
+  declarations: readonly Node[],
+): readonly TSSymbol[] {
+  const { queries } = project;
+  const valued = declarations.flatMap((node) =>
+    (isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
+    node.type === undefined &&
+    !isFunctionLikeDeclaration(node.initializer ?? node)
+      ? [node.name]
+      : [],
+  );
+  const types: Type[] = [];
+  queries.typesAt(valued).forEach((type) => {
+    if (type !== UNANSWERED && type !== undefined) {
+      types.push(type);
+    }
+  });
+  for (const node of declarations) {
+    const signature = isFunctionLikeDeclaration(node)
+      ? node
+      : isVariableDeclaration(node) &&
+          node.type === undefined &&
+          node.initializer !== undefined &&
+          isFunctionLikeDeclaration(node.initializer)
+        ? node.initializer
+        : undefined;
+    if (signature === undefined || signature.type !== undefined || signature.body === undefined) {
+      continue;
+    }
+    const typed = queries.signatureOf(signature);
+    const result =
+      typed === UNANSWERED || typed === undefined ? undefined : queries.returnTypeOf(typed);
+    if (result !== UNANSWERED && result !== undefined) {
+      types.push(result);
+    }
+  }
+  const found = new Map<number, TSSymbol>();
+  const seen = new Set<Type>();
+  const visit = (type: Type, depth: number): void => {
+    if (depth > INFERRED_DEPTH || seen.has(type)) {
+      return;
+    }
+    seen.add(type);
+    const symbol = queries.symbolOfType(type);
+    if (symbol !== UNANSWERED && symbol !== undefined) {
+      found.set(symbol.id, symbol);
+    }
+    const parts = queries.constituents(type);
+    const args = queries.typeArguments(type);
+    for (const next of [
+      ...(parts === UNANSWERED || (parts.length === 1 && parts[0] === type) ? [] : parts),
+      ...(args === UNANSWERED ? [] : args),
+    ]) {
+      visit(next, depth + 1);
+    }
   };
+  types.forEach((type) => {
+    visit(type, 0);
+  });
+  return [...found.values()];
 }
 
 /**

package/src/run.ts

@@ -1,6 +1,5 @@
 import { ConfigError, REPOSITORY_DOCUMENT, type Inputs } from "./config.ts";
 import { DiscoveryError, renderDiagnostic } from "./discover.ts";
-import { EMITTERS } from "./findings/emitters.ts";
 import type { Host } from "./host.ts";
 import { joinPath, resolvePath } from "./paths.ts";
 import { readScope, ScopeError, scopeForDir, type Scope } from "./scope.ts";
@@ -264,7 +263,6 @@ function invoke(
         });
         return opened;
       },
-      emitters: EMITTERS,
     });
   } catch (error: unknown) {
     opened?.close();

package/src/schema.ts

@@ -15,7 +15,7 @@ import { ConfigError } from "./config.ts";
  * - `object` is one setting written as an object: its member names are declared
  *   and a source supplies the object whole.
  */
-export type KeyKind = "leaf" | "section" | "map" | "list" | "object";
+type KeyKind = "leaf" | "section" | "map" | "list" | "object";
 
 /**
  * One node of the closed key list. `members` holds a section's declared members,
@@ -259,7 +259,7 @@ export function malformed(label: string, path: string, detail: string): ConfigEr
  * A refusal of a key the closed key list does not declare, naming the nearest key
  * it does.
  */
-export function unimplementedKey(label: string, path: string): ConfigError {
+function unimplementedKey(label: string, path: string): ConfigError {
   const nearest = nearestKey(path);
   let hint = "";
   if (nearest === path) {

package/src/scope.ts

@@ -4,8 +4,8 @@ import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
 import { checkDocument, type KeyNode } from "./schema.ts";
 
 /** The roles a scope document declares for a module. */
-export const ROLE_TARGET = "target";
-export const ROLE_CONSUMER = "consumer";
+const ROLE_TARGET = "target";
+const ROLE_CONSUMER = "consumer";
 
 /**
  * A scope document above this length is refused rather than decoded. It names one

package/src/session.ts

@@ -347,7 +347,13 @@ function viewOf<Brand>(
       if ((symbol.flags & SymbolFlags.Alias) === 0) {
         return undefined;
       }
-      const held = queries.immediateAliased(symbol);
+      // An alias the checker synthesizes declares nothing, the default a module that assigns
+      // its export gets under esModuleInterop, and the immediate step fails on it while the
+      // whole resolution answers.
+      const held =
+        symbol.declarations.length === 0
+          ? queries.aliased(symbol)
+          : queries.immediateAliased(symbol);
       // An alias that resolves to nothing answers with the checker's own unknown
       // symbol, which declares nothing; a symbol that is no alias answers with
       // nothing at all.
@@ -411,7 +417,6 @@ export function ownedAs<Brand>(
 
 /** Every diagnostic set a project is refused for carrying an error in. */
 export interface ProjectDiagnostics {
-  readonly configFile: string;
   readonly syntactic: readonly Diagnostic[];
   readonly semantic: readonly Diagnostic[];
   readonly configParsing: readonly Diagnostic[];
@@ -425,7 +430,6 @@ export interface ProjectDiagnostics {
 /** The three diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf<Brand>(project: ProjectView<Brand>): ProjectDiagnostics {
   return {
-    configFile: project.configFile,
     syntactic: project.program.getSyntacticDiagnostics(),
     semantic: project.program.getSemanticDiagnostics(),
     configParsing: project.program.getConfigFileParsingDiagnostics(),

package/src/source-files.ts

@@ -38,6 +38,8 @@ export interface SourceFiles {
    * nothing.
    */
   named(path: string): readonly SourceFile[];
+  /** The directories the project writes its output below, absolute: its output and declaration directories. */
+  readonly outputDirs: readonly string[];
 }
 
 /**
@@ -76,6 +78,7 @@ export function sourceFilesOf<Brand>(project: ProjectView<Brand>, targetRoot: st
   return {
     byPath,
     byName,
+    outputDirs: [...new Set([outDir, declarationDir])].filter((dir) => dir !== undefined),
     named: (path) => {
       if (!path.includes(SUBPATH_WILDCARD)) {
         for (const candidate of candidates(path)) {

package/src/stores.ts

@@ -37,7 +37,7 @@ export interface Stores {
 }
 
 /** What one configuration contributes to the run's stores. */
-export interface ConfigurationStores {
+interface ConfigurationStores {
   readonly references: readonly Reference[];
   readonly accessors: readonly string[];
 }

package/src/suppress-inline.ts

@@ -37,7 +37,7 @@ const NO_REASON = new RegExp(DIRECTIVE_EXPRESSIONS.noReason);
 const DIRECTIVE_FORM = "// deadset:ignore DS0000[,DS0000...] -- <reason>";
 
 /** What the grammar's decision procedure makes of one comment. */
-export type Directive =
+type Directive =
   | { readonly is: "none" }
   | { readonly is: "directive"; readonly codes: readonly string[]; readonly reason: string }
   | { readonly is: "no-reason"; readonly codes: readonly string[] }
@@ -64,7 +64,7 @@ export function classifyComment(text: string): Directive {
 }
 
 /** One `//` line comment: the offset of its first solidus, and its text to the end of its line. */
-export interface LineComment {
+interface LineComment {
   readonly offset: number;
   readonly text: string;
 }
@@ -123,7 +123,7 @@ export function tokenStart(text: string, from: number): number {
  * syntax tree holds are skipped, so a `//` inside a string, a template or a regular
  * expression starts nothing.
  */
-export function lineComments(file: SourceFile): readonly LineComment[] {
+function lineComments(file: SourceFile): readonly LineComment[] {
   const text = file.text;
   const spans: { readonly start: number; readonly end: number }[] = [];
   const visit = (node: Node): void => {