@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/src/{workspace-resolution.ts → load/workspace-resolution.ts}

@@ -1,17 +1,26 @@
 /**
- * Which file an import of a workspace package's name is read from. The package is the
- * one `node_modules` links the importer to or, with no link, the one the importer's
- * manifest depends on. A source file the compiler reaches stands; any other file is read
- * back to the source it is compiled from or to a manifest target that is source, a file
- * the package's configurations neither compile nor write is read as installed, and an
- * import nothing answers for is unresolved.
+ * Which file an import of a workspace package's name is read from: the package
+ * `node_modules` links the importer to or, with no link, the one its manifest depends on.
+ * A source file the compiler reaches stands; any other file reads back to its source or to
+ * a manifest target that is source, an ignored file to the source its path mirrors, a file
+ * the package neither compiles nor writes is read as installed, and the rest is unresolved.
  */
 
 import { emittedFrom } from "./emit-map.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
-import { satisfies } from "./version-range.ts";
+import { packageOfSpecifier } from "../dependencies.ts";
+import { gitIgnored } from "../git-ignore.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.ts";
+import { satisfies } from "../version-range.ts";
 import type { Workspace, WorkspaceMember } from "./workspace.ts";
+import { isRecord } from "../json-document.ts";
+import { MANIFEST } from "../fs/manifest.ts";
+import {
+  dependencySpecifiers,
+  installedPackage,
+  manifestsAbove,
+  type ManifestAt,
+} from "./module-lookup.ts";
 
 /** What the compiler's own resolution answered for one import. */
 export interface DefaultResolution {
@@ -36,39 +45,9 @@ export type MemberResolution =
 /** The manifest members that name an entry point for the subpath `.` without `exports`. */
 const LEGACY_MEMBERS = ["types", "typings", "module", "main"] as const;
 
-/** The dependency members a manifest declares other packages under. */
-const DEPENDENCY_MEMBERS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-] as const;
-
 const SOURCE = /(?<!\.d)\.(?:[mc]?ts|tsx)$/u;
 const OUTPUT = /(?:\.d\.[mc]?ts|\.[mc]?js|\.jsx)$/u;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** The package name a bare specifier names, or `undefined` for any other specifier. */
-export function packageNameOf(specifier: string): string | undefined {
-  if (
-    specifier === "" ||
-    specifier.startsWith(".") ||
-    specifier.startsWith("#") ||
-    isAbsolutePath(specifier) ||
-    specifier.includes(":")
-  ) {
-    return undefined;
-  }
-  const [first, second] = specifier.split("/");
-  if (specifier.startsWith("@")) {
-    return second === undefined || second === "" ? undefined : `${first ?? ""}/${second}`;
-  }
-  return first;
-}
-
 function inside(dir: string, path: string): boolean {
   return relativePath(dir, path) !== undefined;
 }
@@ -210,26 +189,32 @@ type Linked =
 /** The member imports of one workspace, read from the members' sources. */
 export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceResolver {
   const links = new Map<string, string | undefined>();
-  /** The directory `node_modules/<name>` names from one directory, links followed. */
+  /** The directory the package `name` installed for one directory is, links followed. */
   const linkedFrom = (name: string, dir: string): string | undefined => {
     const key = `${name}\u0000${dir}`;
-    if (links.has(key)) {
-      return links.get(key);
-    }
-    const candidate = joinPath(dir, "node_modules", name);
-    let found: string | undefined;
-    if (host.kindOf(candidate) === "absent") {
-      const up = dirnamePath(dir);
-      found = up === dir ? undefined : linkedFrom(name, up);
-    } else {
+    if (!links.has(key)) {
+      const installed = installedPackage(host, dir, name);
+      let found: string | undefined;
       try {
-        found = host.realPath(candidate);
+        found = installed === undefined ? undefined : host.realPath(installed);
       } catch {
         found = undefined;
       }
+      links.set(key, found);
+    }
+    return links.get(key);
+  };
+
+  const root = workspace.members[0]?.dir;
+  const ignored = root === undefined ? () => false : gitIgnored(host, root);
+  const manifests = new Map<string, ManifestAt | undefined>();
+  /** The nearest manifest at or above one directory, up to the workspace's root. */
+  const nearestManifest = (dir: string): ManifestAt | undefined => {
+    if (!manifests.has(dir)) {
+      const [nearest] = manifestsAbove(host, dir, root ?? dir);
+      manifests.set(dir, nearest);
     }
-    links.set(key, found);
-    return found;
+    return manifests.get(dir);
   };
 
   const linkOf = (candidates: readonly WorkspaceMember[], fromDir: string): Linked => {
@@ -239,18 +224,18 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       const member = candidates.find((one) => one.dir === linked);
       return member === undefined ? { kind: "none" } : { kind: "member", member };
     }
-    const scope = workspace.memberOf(joinPath(fromDir, "package.json"));
+    const scope = workspace.memberOf(joinPath(fromDir, MANIFEST));
     if (scope?.name === name) {
       return { kind: "member", member: scope };
     }
-    const manifest = scope?.manifest;
-    const declared = DEPENDENCY_MEMBERS.flatMap((field) => {
-      const held = manifest?.[field];
-      const specifier = isRecord(held) ? held[name] : undefined;
-      return typeof specifier === "string" ? [specifier] : [];
-    });
+    // A package below the root that no workspace lists depends on a member as a member does.
+    const owner = scope ?? nearestManifest(fromDir);
+    const manifest = owner?.manifest;
+    const declared = (manifest === undefined ? [] : dependencySpecifiers(manifest, name)).filter(
+      (specifier) => typeof specifier === "string",
+    );
     const matched = candidates.filter((member) =>
-      declared.some((specifier) => dependsOn(specifier, member, scope?.dir ?? fromDir)),
+      declared.some((specifier) => dependsOn(specifier, member, owner?.dir ?? fromDir)),
     );
     const [one, two] = matched;
     if (one === undefined) {
@@ -265,6 +250,25 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
   const compiled = (member: WorkspaceMember, path: string): boolean =>
     member.configurations.some((configuration) => configuration.fileNames.has(path));
 
+  /**
+   * The member's source an ignored output path mirrors: the path below one of its
+   * directories, the deepest first, read below the member's own directory as an output
+   * directory's tree mirrors its root directory's, which a build leaves in an ignored
+   * directory however its configuration writes it.
+   */
+  const mirrored = (member: WorkspaceMember, path: string): string | undefined => {
+    for (const dir of ancestors(dirnamePath(path), member.dir).filter((at) => at !== member.dir)) {
+      const found = emittedFrom(path, { outDir: dir, sourceDirs: [member.dir] }).find(
+        (candidate) =>
+          SOURCE.test(candidate) && !ignored(candidate) && host.kindOf(candidate) === "file",
+      );
+      if (found !== undefined) {
+        return found;
+      }
+    }
+    return undefined;
+  };
+
   /**
    * The member's source one of its paths is, or is compiled from: a TypeScript source
    * file, the source an output path maps back to, or a file one of the member's
@@ -286,6 +290,9 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     if (found !== undefined) {
       return found;
     }
+    if (ignored(path)) {
+      return mirrored(member, path);
+    }
     return compiled(member, path) && host.kindOf(path) === "file" ? path : undefined;
   };
 
@@ -329,11 +336,11 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
     workspace,
     sourceOf,
     names: (specifier) => {
-      const name = packageNameOf(specifier);
+      const name = packageOfSpecifier(specifier);
       return name !== undefined && workspace.named.has(name);
     },
     resolve(specifier, fromDir, conditions, answered) {
-      const name = packageNameOf(specifier);
+      const name = packageOfSpecifier(specifier);
       const candidates = name === undefined ? undefined : workspace.named.get(name);
       if (name === undefined || candidates === undefined) {
         return { kind: "default" };
@@ -352,10 +359,12 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       }
       const { member } = linked;
       // A member no compiler configuration builds is read as the package manager
-      // installed it, wherever the compiler's resolution found it.
+      // installed it, wherever the compiler's resolution found it, unless what it found is
+      // a file the tree ignores, which no install wrote.
       if (
         answered !== undefined &&
-        (member.configurations.length === 0 || !inside(member.dir, answered.resolvedFileName))
+        ((member.configurations.length === 0 && !ignored(answered.resolvedFileName)) ||
+          !inside(member.dir, answered.resolvedFileName))
       ) {
         return { kind: "default" };
       }

package/src/{workspace-run.ts → load/workspace-run.ts}

@@ -5,24 +5,26 @@
  * the members' manifests name. A target in no workspace reads none of it.
  */
 
-import type { LocatedDiagnostic } from "./discover.ts";
-import type { Host } from "./host.ts";
-import type { Manifest, ManifestEntry } from "./manifest.ts";
-import { relativePath } from "./paths.ts";
-import type { Engine } from "./session.ts";
-import { findWorkspace, referenceOnlyIn, type ParsedLayout } from "./workspace.ts";
+import type { Host } from "../host.ts";
+import type { Manifest, ManifestEntry } from "../manifest.ts";
+import { relativePath } from "../paths.ts";
+import type { Engine } from "../session.ts";
+import type { LocatedDiagnostic } from "./diagnostics.ts";
+import type { Build } from "./plan.ts";
+import { referenceOnlyIn, type ParsedLayout, type Workspace } from "./workspace.ts";
 import { memberEntries, targetManifestIn } from "./workspace-manifests.ts";
 import {
   workspacePrograms,
   type MemberReading,
-  type WorkspaceProgram,
+  type PlannedConfiguration,
 } from "./workspace-programs.ts";
 import { workspaceResolver } from "./workspace-resolution.ts";
 
 /** One run's workspace. */
-interface WorkspaceRun {
+export interface WorkspaceRun {
+  readonly workspace: Workspace;
   /** Per configuration that imports a member, how the snapshot reads it. */
-  readonly programs: ReadonlyMap<string, WorkspaceProgram>;
+  readonly programs: ReadonlyMap<string, Exclude<Build, { readonly kind: "project" }>>;
   /**
    * Per configuration whose component files the run cannot read, the reason, in the
    * order the configurations are named.
@@ -50,11 +52,10 @@ interface WorkspaceRun {
   readonly manifest: Manifest;
   /** The entry points the other members' manifests name. */
   readonly entries: readonly ManifestEntry[];
-  /** The directory of every member, the target's included, in the workspace's order. */
-  readonly memberDirs: readonly string[];
 }
 
-function layoutOf(engine: Engine, configFile: string): ParsedLayout | undefined {
+/** What one member's configuration file says of its layout, or `undefined` where it does not parse. */
+export function layoutOf(engine: Engine, configFile: string): ParsedLayout | undefined {
   try {
     const parsed = engine.parseConfigFile(configFile);
     return {
@@ -96,15 +97,16 @@ export function workspaceRun(
   engine: Engine,
   host: Host,
   targetRoot: string,
-  configFiles: readonly string[],
+  configurations: readonly PlannedConfiguration[],
   manifest: Manifest,
+  workspace: Workspace | undefined,
 ): WorkspaceRun | undefined {
-  const workspace = findWorkspace(host, targetRoot, (configFile) => layoutOf(engine, configFile));
   if (workspace === undefined) {
     return undefined;
   }
+
   const resolver = workspaceResolver(host, workspace);
-  const read = workspacePrograms(engine, host, configFiles, resolver);
+  const read = workspacePrograms(engine, host, configurations, resolver);
   const readings = new Map(read.readings.map((reading) => [reading.configFile, reading]));
   const referenceOnly = (
     configFile: string,
@@ -115,6 +117,7 @@ export function workspaceRun(
       new Set([...(readings.get(configFile)?.fileNames ?? []), ...compiled]),
     );
   return {
+    workspace,
     programs: read.programs,
     componentsUnread: read.readings.flatMap(({ configFile, componentsUnread }) =>
       componentsUnread === undefined ? [] : [{ configFile, reason: componentsUnread }],
@@ -132,7 +135,6 @@ export function workspaceRun(
         : !fromExternalLibrary,
     manifest: targetManifestIn(resolver, targetRoot, manifest),
     entries: memberEntries(host, resolver, targetRoot),
-    memberDirs: workspace.members.map((member) => member.dir),
   };
 }
 

package/src/{workspace.ts → load/workspace.ts}

@@ -1,18 +1,28 @@
 /**
  * The workspace a target sits in: the packages `pnpm-workspace.yaml` or a manifest's
- * `workspaces` declares in the nearest directory at or above the target root, up to
- * its repository root, where its patterns name the package the target is in, each
- * with the compiler configurations in its directory. A
- * member is the workspace root or a directory the patterns name that holds a named
- * manifest, never one below `node_modules`.
+ * `workspaces` declares in the nearest directory at or above the target root, up to its
+ * repository root, where its patterns name the package the target is in, each with the
+ * compiler configurations in its directory.
  */
 
-import { DiscoveryError } from "./discover.ts";
+import { configFilesIn } from "./discover.ts";
+import { failureExit } from "../failure.ts";
 import type { EmitLayout } from "./emit-map.ts";
 import { commonDirectory } from "./emit-map.ts";
-import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath } from "./paths.ts";
-import { pnpmPackages } from "./pnpm-workspace.ts";
+import type { Host } from "../host.ts";
+import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.ts";
+import { bytewise } from "../text/compare.ts";
+import { isRecord } from "../json-document.ts";
+import { directoriesIn, repositoryOf } from "../fs/tree.ts";
+import {
+  holdsManifest,
+  inInstalledPackages,
+  INSTALLED_PACKAGES,
+  MANIFEST,
+  manifestAt,
+} from "../fs/manifest.ts";
+import { braceExpanded, pathMatches, segmentMatches } from "../text/glob.ts";
+import { yamlKey } from "../text/yaml.ts";
 
 /** What one compiler configuration of a member says about where it reads and writes. */
 export interface ParsedLayout {
@@ -39,12 +49,17 @@ export interface WorkspaceMember {
   /** Whether the manifest forbids publishing it, so nothing outside the workspace imports it. */
   readonly private: boolean;
   readonly manifest: Readonly<Record<string, unknown>>;
-  /** Every `tsconfig*.json` directly in its directory that parses, by file name. */
+  /**
+   * The programs the run forms in its directory, then every configuration file directly in
+   * it a derived matrix opens that parses, by file name.
+   */
   readonly configurations: readonly MemberConfiguration[];
 }
 
 /** The workspace one target sits in. */
 export interface Workspace {
+  /** The directory that declares the workspace, absolute. */
+  readonly root: string;
   /** Every member, the root first, then by directory. */
   readonly members: readonly WorkspaceMember[];
   /** The members one package name names; two members may share a name. */
@@ -56,29 +71,7 @@ export interface Workspace {
   memberOf(path: string): WorkspaceMember | undefined;
 }
 
-const MANIFEST = "package.json";
 const PNPM_WORKSPACE = "pnpm-workspace.yaml";
-const CONFIG_FILE = /^tsconfig.*\.json$/u;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** One manifest, decoded, or `undefined` where there is none to read. */
-function manifestAt(host: Host, dir: string): Record<string, unknown> | undefined {
-  let text: string;
-  try {
-    text = host.readFile(joinPath(dir, MANIFEST));
-  } catch {
-    return undefined;
-  }
-  try {
-    const value: unknown = JSON.parse(text);
-    return isRecord(value) ? value : undefined;
-  } catch {
-    return undefined;
-  }
-}
 
 /** The patterns one directory declares a workspace with, or `undefined` where it declares none. */
 function declarationAt(
@@ -87,14 +80,20 @@ function declarationAt(
 ): { readonly file: string; readonly patterns: readonly string[] } | undefined {
   const pnpm = joinPath(dir, PNPM_WORKSPACE);
   if (host.kindOf(pnpm) === "file") {
-    const read = pnpmPackages(host.readFile(pnpm));
-    if (read.kind === "refused") {
-      throw new DiscoveryError(
-        `${pnpm}: ${read.reason}; the workspace's packages are read from a sequence of strings`,
-        [],
+    const read = yamlKey(host.readFile(pnpm), "packages");
+    if (read.kind === "absent") {
+      return { file: pnpm, patterns: [] };
+    }
+    const listed = read.kind === "value" ? read.value : undefined;
+    if (!Array.isArray(listed) || !listed.every((entry) => typeof entry === "string")) {
+      const reason =
+        read.kind === "refused" ? read.reason : "packages is not a sequence of strings";
+      throw failureExit(
+        "no-program",
+        `${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings: correct the declaration`,
       );
     }
-    return { file: pnpm, patterns: read.kind === "listed" ? read.patterns : [] };
+    return { file: pnpm, patterns: listed };
   }
   const manifest = manifestAt(host, dir);
   if (manifest === undefined || !Object.hasOwn(manifest, "workspaces")) {
@@ -103,9 +102,9 @@ function declarationAt(
   const declared = manifest["workspaces"];
   const list = isRecord(declared) ? declared["packages"] : declared;
   if (!Array.isArray(list) || !list.every((entry) => typeof entry === "string")) {
-    throw new DiscoveryError(
-      `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one`,
-      [],
+    throw failureExit(
+      "no-program",
+      `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one: correct the declaration`,
     );
   }
   return { file: joinPath(dir, MANIFEST), patterns: list };
@@ -120,21 +119,6 @@ function declaresWorkspace(host: Host, dir: string): boolean {
   return manifest !== undefined && Object.hasOwn(manifest, "workspaces");
 }
 
-/** A pattern with every brace list expanded into its alternatives. */
-function braceExpanded(pattern: string): readonly string[] {
-  const open = pattern.indexOf("{");
-  const close = open < 0 ? -1 : pattern.indexOf("}", open);
-  if (close < 0) {
-    return [pattern];
-  }
-  const before = pattern.slice(0, open);
-  const after = pattern.slice(close + 1);
-  return pattern
-    .slice(open + 1, close)
-    .split(",")
-    .flatMap((member) => braceExpanded(before + member + after));
-}
-
 /**
  * The segments of one pattern below the workspace root, `.` and empty segments
  * dropped and `..` taken back, or `undefined` where it leaves the root.
@@ -156,56 +140,6 @@ function segmentsOf(pattern: string): readonly string[] | undefined {
   return segments;
 }
 
-/**
- * Whether one directory name matches one pattern segment: `*` stands for any run of
- * characters and `?` for one, and neither matches a leading dot.
- */
-function segmentMatches(segment: string, name: string): boolean {
-  if (name.startsWith(".") && !segment.startsWith(".")) {
-    return false;
-  }
-  const source = Array.from(segment)
-    .map((character) => {
-      if (character === "*") {
-        return ".*";
-      }
-      if (character === "?") {
-        return ".";
-      }
-      return character.replaceAll(/[.+^${}()|[\]\\/]/gu, (c) => `\\${c}`);
-    })
-    .join("");
-  return new RegExp(`^${source}$`, "u").test(name);
-}
-
-/** Whether one path's segments match one pattern's, `**` standing for any run of segments. */
-function pathMatches(pattern: readonly string[], path: readonly string[]): boolean {
-  const [head, ...rest] = pattern;
-  if (head === undefined) {
-    return path.length === 0;
-  }
-  if (head === "**") {
-    return (
-      pathMatches(rest, path) ||
-      (path.length > 0 && !(path[0] ?? "").startsWith(".") && pathMatches(pattern, path.slice(1)))
-    );
-  }
-  const [name, ...below] = path;
-  return name !== undefined && segmentMatches(head, name) && pathMatches(rest, below);
-}
-
-function subdirectories(host: Host, dir: string): readonly string[] {
-  try {
-    return host
-      .readDirectory(dir)
-      .filter((entry) => entry.directory && entry.name !== "node_modules" && entry.name !== ".git")
-      .map((entry) => entry.name)
-      .sort();
-  } catch {
-    return [];
-  }
-}
-
 /**
  * Every directory below `dir` one pattern names. `**` does not descend into a
  * directory that declares a workspace of its own, whose packages are that
@@ -219,7 +153,7 @@ function expand(host: Host, dir: string, pattern: readonly string[], into: Set<s
   }
   if (head === "**") {
     expand(host, dir, rest, into);
-    for (const name of subdirectories(host, dir)) {
+    for (const name of directoriesIn(host, dir)) {
       if (name.startsWith(".")) {
         continue;
       }
@@ -230,12 +164,12 @@ function expand(host: Host, dir: string, pattern: readonly string[], into: Set<s
   }
   if (!head.includes("*") && !head.includes("?")) {
     const child = joinPath(dir, head);
-    if (head !== "node_modules" && host.kindOf(child) === "directory") {
+    if (head !== INSTALLED_PACKAGES && host.kindOf(child) === "directory") {
       expand(host, child, rest, into);
     }
     return;
   }
-  for (const name of subdirectories(host, dir)) {
+  for (const name of directoriesIn(host, dir)) {
     if (segmentMatches(head, name)) {
       expand(host, joinPath(dir, name), rest, into);
     }
@@ -277,10 +211,10 @@ function namesDirectory(root: string, patterns: readonly string[], dir: string):
   if (below === undefined) {
     return false;
   }
-  const path = below.split("/");
-  if (path.includes("node_modules")) {
+  if (inInstalledPackages(below)) {
     return false;
   }
+  const path = below.split("/");
   let named = false;
   for (const written of patterns) {
     const negated = written.startsWith("!");
@@ -314,17 +248,7 @@ function configurationsOf(
   dir: string,
   parse: (configFile: string) => ParsedLayout | undefined,
 ): readonly MemberConfiguration[] {
-  let names: readonly string[];
-  try {
-    names = host
-      .readDirectory(dir)
-      .filter((entry) => !entry.directory && CONFIG_FILE.test(entry.name))
-      .map((entry) => entry.name)
-      .sort();
-  } catch {
-    return [];
-  }
-  return names.flatMap((name) => {
+  return configFilesIn(host, dir).flatMap((name) => {
     const configFile = joinPath(dir, name);
     const parsed = parse(configFile);
     return parsed === undefined
@@ -353,22 +277,17 @@ function nearestDeclaration(
       readonly highestPackage: string | undefined;
     }
   | undefined {
-  let dir = targetRoot;
   let highestPackage: string | undefined;
-  for (;;) {
+  for (const dir of ancestors(targetRoot, repositoryOf(host, targetRoot)?.root)) {
     const declared = declarationAt(host, dir);
     if (declared !== undefined) {
       return { root: dir, ...declared, highestPackage };
     }
-    if (host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+    if (holdsManifest(host, dir)) {
       highestPackage = dir;
     }
-    const up = dirnamePath(dir);
-    if (up === dir || host.kindOf(joinPath(dir, ".git")) !== "absent") {
-      return undefined;
-    }
-    dir = up;
   }
+  return undefined;
 }
 
 /**
@@ -376,12 +295,14 @@ function nearestDeclaration(
  * from the target root up to its repository root declares one with a member beside
  * its root, or the nearest one does not name the highest package below it, at or
  * above the target root, among its members. `parse` reads one compiler configuration,
- * or answers `undefined` where it does not read.
+ * or answers `undefined` where it does not read. `known`, a workspace already read, is the
+ * answer where the nearest declaration is its own, so its members are not listed again.
  */
 export function findWorkspace(
   host: Host,
   targetRoot: string,
   parse: (configFile: string) => ParsedLayout | undefined,
+  known?: Workspace,
 ): Workspace | undefined {
   const declared = nearestDeclaration(host, targetRoot);
   if (declared === undefined) {
@@ -393,6 +314,9 @@ export function findWorkspace(
   ) {
     return undefined;
   }
+  if (known?.root === declared.root) {
+    return known;
+  }
   const members: WorkspaceMember[] = [];
   for (const dir of memberDirectories(host, declared.root, declared.patterns)) {
     const manifest = manifestAt(host, dir);
@@ -414,8 +338,12 @@ export function findWorkspace(
     return undefined;
   }
   members.sort((a, b) =>
-    a.dir === declared.root ? -1 : b.dir === declared.root ? 1 : a.dir < b.dir ? -1 : 1,
+    a.dir === declared.root ? -1 : b.dir === declared.root ? 1 : bytewise(a.dir, b.dir),
   );
+  return assembled(host, declared.root, members);
+}
+
+function assembled(host: Host, root: string, members: readonly WorkspaceMember[]): Workspace {
   const named = new Map<string, WorkspaceMember[]>();
   for (const member of members) {
     named.set(member.name, [...(named.get(member.name) ?? []), member]);
@@ -427,12 +355,12 @@ export function findWorkspace(
       return scopes.get(dir);
     }
     const up = dirnamePath(dir);
-    const found =
-      host.kindOf(joinPath(dir, MANIFEST)) === "file" ? dir : up === dir ? undefined : scopeOf(up);
+    const found = holdsManifest(host, dir) ? dir : up === dir ? undefined : scopeOf(up);
     scopes.set(dir, found);
     return found;
   };
   return {
+    root,
     members,
     named,
     memberOf: (path) => {
@@ -442,6 +370,34 @@ export function findWorkspace(
   };
 }
 
+/**
+ * The workspace with the programs the run forms put first among each member's configurations,
+ * by the member's directory: a formed program has no file on disk to list, so its file list
+ * is what makes a member's JavaScript its source.
+ */
+export function withFormed(
+  host: Host,
+  workspace: Workspace,
+  formed: ReadonlyMap<string, readonly ParsedLayout[]>,
+): Workspace {
+  return assembled(
+    host,
+    workspace.root,
+    workspace.members.map((member) => {
+      const own = formed.get(member.dir) ?? [];
+      return own.length === 0
+        ? member
+        : {
+            ...member,
+            configurations: [
+              ...own.map((layout) => ({ fileNames: new Set(layout.fileNames) })),
+              ...member.configurations,
+            ],
+          };
+    }),
+  );
+}
+
 /**
  * Whether one configuration holds one file only for the references it makes: the file
  * belongs to a workspace package, the root included, and the configuration does not