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

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";
 
@@ -128,6 +131,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 +328,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 +353,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 +409,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", "");
   }
@@ -560,6 +594,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 +626,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 +660,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/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.

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/sweep.ts

@@ -278,34 +278,46 @@ function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly
 /**
  * Admits every test declaration whose set of referenced production declarations is
  * non-empty and wholly dead, and returns which it admitted. The set is read from every
- * reference the test makes, not the ones the mode counts: a production sweep counts none,
- * which is what makes the targets dead. A test referencing one live target is never
- * admitted, and neither is a marked or exempt test.
+ * reference the test makes, which a production sweep does not count. A test-support
+ * declaration that a test referencing a live target also references is a live target of
+ * every test referencing it. A marked or exempt test is never admitted.
  */
 function admitTestsOfDeadCode(
   graph: Graph,
   dead: boolean[],
   held: readonly boolean[],
 ): readonly boolean[] {
-  const admitted = graph.symbols.map(() => false);
-  graph.symbols.forEach((_symbol, at) => {
-    const testCode = graph.test[at] === true || graph.support[at] === true;
-    if (!testCode || graph.subject[at] !== true || held[at] === true) {
-      return;
-    }
+  const testCode = (at: number): boolean => graph.test[at] === true || graph.support[at] === true;
+  const judged = graph.symbols.map((_symbol, at) => {
     let targets = 0;
     let live = 0;
-    for (const edge of graph.out[at] ?? []) {
-      const target = graph.test[edge.to] === true || graph.support[edge.to] === true;
-      if (target || graph.subject[edge.to] !== true) {
-        continue;
+    if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
+      for (const edge of graph.out[at] ?? []) {
+        if (testCode(edge.to) || graph.subject[edge.to] !== true) {
+          continue;
+        }
+        targets += 1;
+        if (dead[edge.to] !== true) {
+          live += 1;
+        }
       }
-      targets += 1;
-      if (dead[edge.to] !== true) {
-        live += 1;
+    }
+    return { targets, live };
+  });
+  const shared = new Set<number>();
+  judged.forEach(({ live }, at) => {
+    if (live > 0) {
+      for (const edge of graph.out[at] ?? []) {
+        if (graph.support[edge.to] === true) {
+          shared.add(edge.to);
+        }
       }
     }
-    if (targets > 0 && live === 0) {
+  });
+  const admitted = graph.symbols.map(() => false);
+  judged.forEach(({ targets, live }, at) => {
+    const sharing = (graph.out[at] ?? []).some((edge) => shared.has(edge.to) && edge.to !== at);
+    if (targets > 0 && live === 0 && !sharing) {
       dead[at] = true;
       admitted[at] = true;
     }

package/src/symbol-keys.ts

@@ -0,0 +1,172 @@
+/**
+ * The members a unique symbol keys, used through element accesses. `value[key]`, where
+ * `key` is a constant of a `unique symbol` type, reads the member of the receiver's type
+ * whose computed name is that same constant, and a store through the access writes it.
+ * No name node resolves to such a member: the key's name resolves to the constant.
+ */
+
+import {
+  isComputedPropertyName,
+  isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isStringLiteral,
+  type ElementAccessExpression,
+  type Node,
+} from "@typescript/native/unstable/ast";
+import type { Symbol as TSSymbol, Type } from "@typescript/native/unstable/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import type { InventorySymbol } from "./inventory.ts";
+import { isAnswered, type PropertyTables } from "./query.ts";
+import type { ProjectView } from "./session.ts";
+
+/** One element access whose key is a name, and how the access uses the member it selects. */
+export interface KeyedAccess {
+  readonly access: ElementAccessExpression;
+  /** The identifier whose symbol is the key: the argument, or the name its property access ends in. */
+  readonly key: Node;
+  readonly from: string;
+  readonly use: "read" | "write" | "both";
+}
+
+/** One keyed access with the symbol its key resolved to. */
+interface ResolvedKey {
+  readonly access: KeyedAccess;
+  readonly symbol: TSSymbol;
+}
+
+/** The members one keyed access selects, by their inventory identifiers. */
+interface KeyedUse {
+  readonly access: KeyedAccess;
+  readonly ids: readonly string[];
+}
+
+/** The identifier an element access's argument names its key by, where it is a name. */
+export function keyNameOf(argument: Node): Node | undefined {
+  let at = argument;
+  while (isParenthesizedExpression(at)) {
+    at = at.expression;
+  }
+  if (isIdentifier(at)) {
+    return at;
+  }
+  return isPropertyAccessExpression(at) && isIdentifier(at.name) ? at.name : undefined;
+}
+
+/**
+ * The last identifier of each computed member name the inventory holds, `mark` for
+ * `[mark]` and `iterator` for `[Symbol.iterator]`: an access whose key is spelled by no
+ * such identifier selects no member a unique symbol keys, and is not asked about.
+ */
+export function computedKeyNames(symbols: readonly InventorySymbol[]): ReadonlySet<string> {
+  const names = new Set<string>();
+  for (const symbol of symbols) {
+    const key = /\[([^\]]+)\]$/u.exec(symbol.name)?.[1];
+    const last = key?.split(".").pop()?.trim();
+    if (last !== undefined && /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(last)) {
+      names.add(last);
+    }
+  }
+  return names;
+}
+
+/** Whether a computed name's expression is literal text, which names a member by its text. */
+function isLiteralKey(expression: Node): boolean {
+  return (
+    isStringLiteral(expression) ||
+    isNumericLiteral(expression) ||
+    isNoSubstitutionTemplateLiteral(expression)
+  );
+}
+
+/**
+ * The members each keyed access selects. The receivers' types are asked in one batch,
+ * each object type's properties once, and the key of every property declared under a
+ * computed name in one batch more; a property is selected where its key and the
+ * access's key are one symbol.
+ */
+export function keyedUses<Brand>(
+  project: ProjectView<Brand>,
+  chains: AliasChains,
+  resolved: readonly ResolvedKey[],
+  properties: PropertyTables,
+  cap: number,
+): readonly KeyedUse[] {
+  if (resolved.length === 0) {
+    return [];
+  }
+  const queries = project.queries;
+  const ownPaths = project.ownPaths();
+  const types = queries.typesAt(
+    resolved.map((one) => one.access.access.expression),
+    cap,
+  );
+
+  const parts = new Map<number, readonly Type[]>();
+  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()) {
+      const constituents = queries.constituents(type);
+      found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+    } else if (type.isObjectType()) {
+      found = [type];
+    }
+    parts.set(type.id, found);
+    return found;
+  };
+
+  /** Each receiver's properties declared in the target under a computed name, with that name's expression. */
+  const candidates = new Map<number, { property: TSSymbol; key: Node }[]>();
+  const keyNodes: Node[] = [];
+  const candidatesOf = (type: Type): readonly { property: TSSymbol; key: Node }[] => {
+    const known = candidates.get(type.id);
+    if (known !== undefined) {
+      return known;
+    }
+    const found: { property: TSSymbol; key: Node }[] = [];
+    const read = properties.of(type);
+    for (const property of isAnswered(read.properties) ? read.properties : []) {
+      const handle = property.declarations.find((one) => ownPaths.has(one.path));
+      const node = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+      const name = (node as { readonly name?: Node } | undefined)?.name;
+      if (name !== undefined && isComputedPropertyName(name) && !isLiteralKey(name.expression)) {
+        found.push({ property, key: name.expression });
+        keyNodes.push(name.expression);
+      }
+    }
+    candidates.set(type.id, found);
+    return found;
+  };
+
+  const perAccess = resolved.map((_one, index) => {
+    const type = types[index];
+    return type === undefined || !isAnswered(type) ? [] : partsOf(type).flatMap(candidatesOf);
+  });
+  const keyOf = new Map<Node, number>();
+  const asked = [...new Set(keyNodes)];
+  (asked.length === 0
+    ? []
+    : project.symbolsAt(
+        asked.map((node) => project.handle(node)),
+        cap,
+      )
+  ).forEach((symbol, index) => {
+    const node = asked[index];
+    if (node !== undefined && symbol !== undefined && isAnswered(symbol)) {
+      keyOf.set(node, symbol.id);
+    }
+  });
+
+  return resolved.flatMap((one, index) => {
+    const ids = (perAccess[index] ?? [])
+      .filter((candidate) => keyOf.get(candidate.key) === one.symbol.id)
+      .flatMap((candidate) => chains.declarationsOf(candidate.property));
+    return ids.length === 0 ? [] : [{ access: one.access, ids: [...new Set(ids)] }];
+  });
+}

package/src/test-joins.ts

@@ -0,0 +1,120 @@
+/**
+ * The test files a derived matrix holds although no configuration's file list names them.
+ * The test runner compiles such a file with the options of the nearest compiler
+ * configuration at or above it, so the file joins that configuration's program as a file
+ * its list names, unless a `package.json` below that configuration's directory makes the
+ * file another package's, which its own test runner compiles.
+ */
+
+import { sourcePaths } from "./file-facts.ts";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+import type { Engine } from "./session.ts";
+import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+
+const PREFERRED = "/tsconfig.json";
+
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a: string, b: string): number {
+  const first = a.endsWith(PREFERRED) ? 0 : 1;
+  const second = b.endsWith(PREFERRED) ? 0 : 1;
+  return first - second || (a < b ? -1 : a > b ? 1 : 0);
+}
+
+/**
+ * Per configuration of `configFiles`, the absolute paths of the test files that join it:
+ * each file below `root` a pattern of `patterns` names, that no configuration's file list
+ * holds, joins the configuration nearest at or above its directory when no `package.json`
+ * sits between them. A configuration the compiler cannot read lists nothing and is joined
+ * by nothing.
+ */
+export function joinedTestFiles(
+  engine: Engine,
+  host: Host,
+  root: string,
+  configFiles: readonly string[],
+  patterns: readonly RegExp[],
+): ReadonlyMap<string, readonly string[]> {
+  const listed = new Set<string>();
+  const byDir = new Map<string, string[]>();
+  for (const configFile of configFiles) {
+    let fileNames: readonly string[];
+    try {
+      fileNames = engine.parseConfigFile(configFile).fileNames;
+    } catch {
+      continue;
+    }
+    fileNames.forEach((name) => listed.add(name));
+    const dir = dirnamePath(configFile);
+    byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
+  }
+  const joins = new Map<string, string[]>();
+  for (const path of sourcePaths(host, root)) {
+    const file = joinPath(root, path);
+    if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
+      continue;
+    }
+    for (let dir = dirnamePath(file); ; dir = dirnamePath(dir)) {
+      const [nearest] = byDir.get(dir) ?? [];
+      if (nearest !== undefined) {
+        joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
+        break;
+      }
+      if (
+        host.kindOf(joinPath(dir, "package.json")) === "file" ||
+        dir === root ||
+        relativePath(root, dir) === undefined
+      ) {
+        break;
+      }
+    }
+  }
+  return joins;
+}
+
+/**
+ * How the snapshot reads each configuration a test file joins: the program `programs`
+ * describes with the files added to its root files, or a configuration only the snapshot
+ * holds that extends the one `programs` writes, or the configuration itself, and lists
+ * every file the configuration lists and the joined ones.
+ */
+export function withJoinedTests(
+  engine: Engine,
+  host: Host,
+  programs: ReadonlyMap<string, WorkspaceProgram>,
+  joins: ReadonlyMap<string, readonly string[]>,
+): ReadonlyMap<string, WorkspaceProgram> {
+  const found = new Map(programs);
+  for (const [configFile, files] of joins) {
+    const program = programs.get(configFile);
+    if (program?.kind === "program") {
+      found.set(configFile, {
+        kind: "program",
+        params: {
+          ...program.params,
+          rootFiles: [...(program.params.rootFiles ?? []), ...files],
+        },
+      });
+      continue;
+    }
+    let listed: readonly string[];
+    try {
+      listed =
+        program?.kind === "configuration"
+          ? engine.parseConfigJson(JSON.parse(program.text), program.file).fileNames
+          : engine.parseConfigFile(configFile).fileNames;
+    } catch {
+      continue;
+    }
+    const value =
+      program?.kind === "configuration"
+        ? { ...(JSON.parse(program.text) as Record<string, unknown>), files: [...listed, ...files] }
+        : { extends: configFile, files: [...listed, ...files] };
+    found.set(configFile, {
+      kind: "configuration",
+      file: program?.kind === "configuration" ? program.file : writtenPath(host, configFile),
+      text: `${JSON.stringify({ ...value, include: [] }, null, 2)}\n`,
+    });
+  }
+  return found;
+}

package/src/version.ts

@@ -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.1.0";
+export const CONTRACT_VERSION = "7.0.0";

package/src/workflow-steps.ts

@@ -69,6 +69,24 @@ export function runCommands(text: string): readonly string[] {
   return found;
 }
 
+/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
+export function workflowTokens(host: Host, targetRoot: string): readonly string[] {
+  const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
+  const found: string[] = [];
+  for (const path of workflowFiles(host, dir)) {
+    let text: string;
+    try {
+      text = host.readFile(path);
+    } catch {
+      continue;
+    }
+    for (const command of runCommands(text)) {
+      found.push(...scriptTokens(command));
+    }
+  }
+  return found;
+}
+
 /**
  * The own files the `run:` steps of every workflow file in the target root's
  * `.github/workflows` name: a token equal to a file's path below the target root, with or
@@ -79,25 +97,14 @@ export function workflowEntries(
   targetRoot: string,
   files: SourceFiles,
 ): readonly WorkflowEntry[] {
-  const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
   const found: WorkflowEntry[] = [];
-  for (const path of workflowFiles(host, dir)) {
-    let text: string;
-    try {
-      text = host.readFile(path);
-    } catch {
+  for (const token of workflowTokens(host, targetRoot)) {
+    if (COMPUTED.test(token)) {
       continue;
     }
-    for (const command of runCommands(text)) {
-      for (const token of scriptTokens(command)) {
-        if (COMPUTED.test(token)) {
-          continue;
-        }
-        const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
-        if (file !== undefined) {
-          found.push({ file, source: token });
-        }
-      }
+    const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
+    if (file !== undefined) {
+      found.push({ file, source: token });
     }
   }
   return found;

package/src/workspace-programs.ts

@@ -126,7 +126,7 @@ function unstatable(reading: Reading): string | undefined {
 }
 
 /** The path beside `configFile` its written configuration takes, which no file has. */
-function writtenPath(host: Host, configFile: string): string {
+export function writtenPath(host: Host, configFile: string): string {
   const stem = configFile.replace(/\.json$/u, "");
   for (let counter = 0; ; counter += 1) {
     const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;